Merge pull request #6 from assimp/master

Merge changes from assimp master

.travis.yml

@@ -51,7 +51,8 @@ matrix:
       env: ANALYZE=ON
     - os: linux
       compiler: gcc
-      env: DISABLE_EXPORTERS=YES ENABLE_COVERALLS=ON
+#      env: DISABLE_EXPORTERS=YES ENABLE_COVERALLS=ON
+      env: ENABLE_COVERALLS=ON
     - os: linux
       compiler: gcc
       env: SHARED_BUILD=ON

AssimpConfig.cmake.in

@@ -1,21 +0,0 @@
-# - Config file for the FooBar package
-# It defines the following variables
-#  FOOBAR_INCLUDE_DIRS - include directories for FooBar
-#  FOOBAR_LIBRARIES    - libraries to link against
-#  FOOBAR_EXECUTABLE   - the bar executable
-
-# Compute paths
-get_filename_component(FOOBAR_CMAKE_DIR "${CMAKE_CURRENT_LIST_FILE}" PATH)
-if(EXISTS "${FOOBAR_CMAKE_DIR}/CMakeCache.txt")
-  # In build tree
-  include("${FOOBAR_CMAKE_DIR}/FooBarBuildTreeSettings.cmake")
-else()
-  set(FOOBAR_INCLUDE_DIRS "${FOOBAR_CMAKE_DIR}/@CONF_REL_INCLUDE_DIR@")
-endif()
-
-# Our library dependencies (contains definitions for IMPORTED targets)
-include("${FOOBAR_CMAKE_DIR}/FooBarLibraryDepends.cmake")
-
-# These are IMPORTED targets created by FooBarLibraryDepends.cmake
-set(FOOBAR_LIBRARIES foo)
-set(FOOBAR_EXECUTABLE bar)

Build.md

@@ -0,0 +1,58 @@
+# Install CMake
+Asset-Importer-Lib can be build for a lot of different platforms. We are using cmake to generate the build environment for these via cmake. So you have to make sure that you have a working cmake-installation on your system. You can download it at https://cmake.org/ or for linux install it via
+```
+sudo apt-get install cmake
+```
+
+# Get the source
+Make sure you have a working git-installation. Open a command prompt and clone the Asset-Importer-Lib via:
+```
+git clone https://github.com/assimp/assimp.git
+```
+
+# Build instructions for Windows with Visual-Studio
+
+First you have to install Visual-Studio on your windows-system. You can get the Community-Version for free here: https://visualstudio.microsoft.com/de/downloads/
+To generate the build environment for your IDE open a command prompt, navigate to your repo and type:
+```
+> cmake CMakeLists.txt
+```
+This will generate the project files for the visual studio. All dependencies used to build Asset-IMporter-Lib shall be part of the repo. If you want to use you own zlib.installation this is possible as well. Check the options for it.
+
+# Build instructions for Windows with UWP
+See https://stackoverflow.com/questions/40803170/cmake-uwp-using-cmake-to-build-universal-windows-app
+
+
+# Build instrcutions for Linux / Unix
+Open a terminal and got to your repository. You can generate the makefiles and build the library via:
+
+```
+cmake CMakeLists.txt
+make -j4
+```
+The option -j descripes the number of parallel processes for the build. In this case make will try to use 4 cores for the build.
+
+If you want to use a IDE for linux you can try QTCreator for instance. 
+
+# CMake build options
+The cmake-build-environment provides options to configure the build. The following options can be used:
+- **BUILD_SHARED_LIBS ( default ON )**: Generation of shared libs ( dll for windows, so for Linux ). Set this to OFF to get a static lib.
+- **BUILD_FRAMEWORK ( default OFF, MacOnly)**: Build package as Mac OS X Framework bundle
+- **ASSIMP_DOUBLE_PRECISION( default OFF )**: All data will be stored as double values.
+- **ASSIMP_OPT_BUILD_PACKAGES ( default OFF)**: Set to ON to generate CPack configuration files and packaging targets
+- **ASSIMP_ANDROID_JNIIOSYSTEM ( default OFF )**: Android JNI IOSystem support is active
+- **ASSIMP_NO_EXPORT ( default OFF )**: Disable Assimp's export functionality
+- **ASSIMP_BUILD_ZLIB ( default OFF )**: Build your own zlib
+- **ASSIMP_BUILD_ASSIMP_TOOLS ( default ON )**: If the supplementary tools for Assimp are built in addition to the library.
+- **ASSIMP_BUILD_SAMPLES ( default OFF )**: If the official samples are built as well (needs Glut).
+- **ASSIMP_BUILD_TESTS ( default ON )**: If the test suite for Assimp is built in addition to the library.
+- **ASSIMP_COVERALLS ( default OFF )**: Enable this to measure test coverage.
+- **ASSIMP_WERROR( default OFF )**: Treat warnings as errors.
+- **ASSIMP_ASAN ( default OFF )**: Enable AddressSanitizer.
+- **ASSIMP_UBSAN ( default OFF )**: Enable Undefined Behavior sanitizer.
+- **SYSTEM_IRRXML ( default OFF )**: Use system installed Irrlicht/IrrXML library.
+- **BUILD_DOCS ( default OFF )**: Build documentation using Doxygen.
+- **INJECT_DEBUG_POSTFIX( default ON )**: Inject debug postfix in .a/.so lib names
+- **IGNORE_GIT_HASH ( default OFF )**: Don't call git to get the hash.
+- **ASSIMP_INSTALL_PDB ( default ON )**: Install MSVC debug files.
+

CMakeLists.txt

@@ -110,10 +110,15 @@ OPTION( INJECT_DEBUG_POSTFIX
   ON
 )
 
+OPTION ( IGNORE_GIT_HASH
+   "Don't call git to get the hash."
+   OFF
+)
+
 IF (IOS)
-	IF (NOT CMAKE_BUILD_TYPE)
- 		SET(CMAKE_BUILD_TYPE "Release")
-	ENDIF (NOT CMAKE_BUILD_TYPE)
+  IF (NOT CMAKE_BUILD_TYPE)
+    SET(CMAKE_BUILD_TYPE "Release")
+  ENDIF (NOT CMAKE_BUILD_TYPE)
 ENDIF (IOS)
 
 # Use subset of Windows.h
@@ -153,23 +158,25 @@ SET( ASSIMP_PACKAGE_VERSION "0" CACHE STRING "the package-specific version used
 # Enable C++1 globally
 set_property( GLOBAL PROPERTY CXX_STANDARD 11 )
 
-# Get the current working branch
-EXECUTE_PROCESS(
-  COMMAND git rev-parse --abbrev-ref HEAD
-  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
-  OUTPUT_VARIABLE GIT_BRANCH
-  OUTPUT_STRIP_TRAILING_WHITESPACE
-  ERROR_QUIET
-)
+IF(NOT IGNORE_GIT_HASH)
+  # Get the current working branch
+  EXECUTE_PROCESS(
+    COMMAND git rev-parse --abbrev-ref HEAD
+    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+    OUTPUT_VARIABLE GIT_BRANCH
+    OUTPUT_STRIP_TRAILING_WHITESPACE
+    ERROR_QUIET
+  )
 
-# Get the latest abbreviated commit hash of the working branch
-EXECUTE_PROCESS(
-  COMMAND git log -1 --format=%h --no-show-signature
-  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
-  OUTPUT_VARIABLE GIT_COMMIT_HASH
-  OUTPUT_STRIP_TRAILING_WHITESPACE
-  ERROR_QUIET
-)
+  # Get the latest abbreviated commit hash of the working branch
+  EXECUTE_PROCESS(
+    COMMAND git rev-parse --short=8 HEAD
+    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+    OUTPUT_VARIABLE GIT_COMMIT_HASH
+    OUTPUT_STRIP_TRAILING_WHITESPACE
+    ERROR_QUIET
+  )
+ENDIF()
 
 IF(NOT GIT_COMMIT_HASH)
   SET(GIT_COMMIT_HASH 0)
@@ -210,25 +217,23 @@ ENDIF( UNIX )
 # Grouped compiler settings
 IF ((CMAKE_C_COMPILER_ID MATCHES "GNU") AND NOT CMAKE_COMPILER_IS_MINGW)
   # hide all not-exported symbols
-  SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g -fvisibility=hidden -fPIC -Wall -std=c++0x")
-  SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fPIC")
+  SET(CMAKE_CXX_FLAGS "-g -fvisibility=hidden -fPIC -fno-strict-aliasing -Wall -std=c++0x ${CMAKE_CXX_FLAGS}")
+  SET(CMAKE_C_FLAGS "-fPIC -fno-strict-aliasing ${CMAKE_C_FLAGS}")
   SET(LIBSTDC++_LIBRARIES -lstdc++)
 ELSEIF(MSVC)
   # enable multi-core compilation with MSVC
   ADD_COMPILE_OPTIONS(/MP)
-  if(CMAKE_SIZEOF_VOID_P EQUAL 8)
-    ADD_COMPILE_OPTIONS( /bigobj )
-  ENDIF()
+  ADD_COMPILE_OPTIONS( /bigobj )
   # disable "elements of array '' will be default initialized" warning on MSVC2013
   IF(MSVC12)
     ADD_COMPILE_OPTIONS(/wd4351)
   ENDIF()
 ELSEIF ( "${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang" )
-  SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g -fvisibility=hidden -fPIC -Wall -Wno-long-long -std=c++11" )
-  SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fPIC")
+  SET(CMAKE_CXX_FLAGS "-g -fvisibility=hidden -fPIC -fno-strict-aliasing -Wall -Wno-long-long -std=c++11 ${CMAKE_CXX_FLAGS}" )
+  SET(CMAKE_C_FLAGS "-fPIC -fno-strict-aliasing ${CMAKE_C_FLAGS}")
 ELSEIF( CMAKE_COMPILER_IS_MINGW )
-  SET( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fvisibility=hidden -Wall -Wno-long-long -std=c++11 -Wa,-mbig-obj" )
-  SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fPIC ")
+  SET( CMAKE_CXX_FLAGS "-fvisibility=hidden -fno-strict-aliasing -Wall -Wno-long-long -std=c++11 -Wa,-mbig-obj ${CMAKE_CXX_FLAGS}" )
+  SET(CMAKE_C_FLAGS "-fPIC -fno-strict-aliasing ${CMAKE_C_FLAGS} ")
   ADD_DEFINITIONS( -U__STRICT_ANSI__ )
 ENDIF()
 
@@ -309,8 +314,18 @@ ENDIF()
 
 # cmake configuration files
 CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/assimp-config.cmake.in"         "${CMAKE_CURRENT_BINARY_DIR}/assimp-config.cmake" @ONLY IMMEDIATE)
+CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/assimpTargets.cmake.in"         "${CMAKE_CURRENT_BINARY_DIR}/assimpTargets.cmake" @ONLY IMMEDIATE)
+CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/assimpTargets-debug.cmake.in"   "${CMAKE_CURRENT_BINARY_DIR}/assimpTargets-debug.cmake" @ONLY IMMEDIATE)
+CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/assimpTargets-release.cmake.in" "${CMAKE_CURRENT_BINARY_DIR}/assimpTargets-release.cmake" @ONLY IMMEDIATE)
 CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/assimp-config-version.cmake.in" "${CMAKE_CURRENT_BINARY_DIR}/assimp-config-version.cmake" @ONLY IMMEDIATE)
-INSTALL(FILES "${CMAKE_CURRENT_BINARY_DIR}/assimp-config.cmake"             "${CMAKE_CURRENT_BINARY_DIR}/assimp-config-version.cmake" DESTINATION "${ASSIMP_LIB_INSTALL_DIR}/cmake/assimp-${ASSIMP_VERSION_MAJOR}.${ASSIMP_VERSION_MINOR}" COMPONENT ${LIBASSIMP-DEV_COMPONENT})
+#we should generated these scripts after CMake VERSION 3.0.2 using export(EXPORT ...) and write_basic_package_version_file(...)
+INSTALL(FILES 
+  "${CMAKE_CURRENT_BINARY_DIR}/assimp-config.cmake"
+  "${CMAKE_CURRENT_BINARY_DIR}/assimp-config-version.cmake"
+  "${CMAKE_CURRENT_BINARY_DIR}/assimpTargets.cmake"
+  "${CMAKE_CURRENT_BINARY_DIR}/assimpTargets-debug.cmake"
+  "${CMAKE_CURRENT_BINARY_DIR}/assimpTargets-release.cmake"
+  DESTINATION "${ASSIMP_LIB_INSTALL_DIR}/cmake/assimp-${ASSIMP_VERSION_MAJOR}.${ASSIMP_VERSION_MINOR}" COMPONENT ${LIBASSIMP-DEV_COMPONENT})
 
 FIND_PACKAGE( DirectX )
 

Readme.md

@@ -115,7 +115,7 @@ __Exporters__:
 - FBX ( experimental )
 
 ### Building ###
-Take a look into the `INSTALL` file. Our build system is CMake, if you used CMake before there is a good chance you know what to do.
+Take a look into the https://github.com/assimp/assimp/blob/master/Build.md file. Our build system is CMake, if you used CMake before there is a good chance you know what to do.
 
 ### Ports ###
 * [Android](port/AndroidJNI/README.md)

assimp-config.cmake.in

@@ -1,59 +1 @@
-# - Find Assimp Installation
-#
-# Users can set the following variables before calling the module:
-#  ASSIMP_DIR - The preferred installation prefix for searching for ASSIMP. Set by the user.
-#
-# ASSIMP_ROOT_DIR - the root directory where the installation can be found
-# ASSIMP_CXX_FLAGS - extra flags for compilation
-# ASSIMP_LINK_FLAGS - extra flags for linking
-# ASSIMP_INCLUDE_DIRS - include directories
-# ASSIMP_LIBRARY_DIRS - link directories
-# ASSIMP_LIBRARIES - libraries to link plugins with
-# ASSIMP_Boost_VERSION - the boost version assimp was compiled with
-get_filename_component(ASSIMP_ROOT_DIR "@CMAKE_INSTALL_PREFIX@" REALPATH)
-
-if( MSVC )
-  # in order to prevent DLL hell, each of the DLLs have to be suffixed with the major version and msvc prefix
-  if( MSVC70 OR MSVC71 )
-    set(MSVC_PREFIX "vc70")
-  elseif( MSVC80 )
-    set(MSVC_PREFIX "vc80")
-  elseif( MSVC90 )
-    set(MSVC_PREFIX "vc90")
-  elseif( MSVC10 )
-    set(MSVC_PREFIX "vc100")
-  elseif( MSVC11 )
-    set(MSVC_PREFIX "vc110")
-  elseif( MSVC12 )
-    set(MSVC_PREFIX "vc120")
-  elseif( MSVC14 )
-    set(MSVC_PREFIX "vc140")
-  else()
-    set(MSVC_PREFIX "vc150")
-  endif()
-  set(ASSIMP_LIBRARY_SUFFIX "@ASSIMP_LIBRARY_SUFFIX@-${MSVC_PREFIX}-mt" CACHE STRING "the suffix for the assimp windows library" )
-else()
-  set(ASSIMP_LIBRARY_SUFFIX "@ASSIMP_LIBRARY_SUFFIX@" CACHE STRING "the suffix for the openrave libraries" )
-endif()
-
-set( ASSIMP_CXX_FLAGS ) # dynamically linked library
-set( ASSIMP_LINK_FLAGS "" )
-set( ASSIMP_LIBRARY_DIRS "${ASSIMP_ROOT_DIR}/@ASSIMP_LIB_INSTALL_DIR@")
-set( ASSIMP_INCLUDE_DIRS "${ASSIMP_ROOT_DIR}/@ASSIMP_INCLUDE_INSTALL_DIR@")
-set( ASSIMP_LIBRARIES assimp${ASSIMP_LIBRARY_SUFFIX})
-set( ASSIMP_LIBRARIES ${ASSIMP_LIBRARIES}@CMAKE_DEBUG_POSTFIX@)
-
-# for compatibility with pkg-config
-set(ASSIMP_CFLAGS_OTHER "${ASSIMP_CXX_FLAGS}")
-set(ASSIMP_LDFLAGS_OTHER "${ASSIMP_LINK_FLAGS}")
-
-MARK_AS_ADVANCED(
-  ASSIMP_ROOT_DIR
-  ASSIMP_CXX_FLAGS
-  ASSIMP_LINK_FLAGS
-  ASSIMP_INCLUDE_DIRS
-  ASSIMP_LIBRARIES
-  ASSIMP_CFLAGS_OTHER
-  ASSIMP_LDFLAGS_OTHER
-  ASSIMP_LIBRARY_SUFFIX
-)
+include(${CMAKE_CURRENT_LIST_DIR}/assimpTargets.cmake)

assimpTargets-debug.cmake.in

@@ -0,0 +1,78 @@
+#----------------------------------------------------------------
+# Generated CMake target import file for configuration "Debug".
+#----------------------------------------------------------------
+
+# Commands may need to know the format version.
+set(CMAKE_IMPORT_FILE_VERSION 1)
+
+if(MSVC)
+  if( MSVC70 OR MSVC71 )
+    set(MSVC_PREFIX "vc70")
+  elseif( MSVC80 )
+    set(MSVC_PREFIX "vc80")
+  elseif( MSVC90 )
+    set(MSVC_PREFIX "vc90")
+  elseif( MSVC10 )
+    set(MSVC_PREFIX "vc100")
+  elseif( MSVC11 )
+    set(MSVC_PREFIX "vc110")
+  elseif( MSVC12 )
+    set(MSVC_PREFIX "vc120")
+  elseif( MSVC14 )
+    set(MSVC_PREFIX "vc140")
+  else()
+    set(MSVC_PREFIX "vc150")
+  endif()
+  set(ASSIMP_LIBRARY_SUFFIX "@ASSIMP_LIBRARY_SUFFIX@-${MSVC_PREFIX}-mt" CACHE STRING "the suffix for the assimp windows library" )
+
+  set(sharedLibraryName "assimp${ASSIMP_LIBRARY_SUFFIX}@CMAKE_DEBUG_POSTFIX@@CMAKE_SHARED_LIBRARY_SUFFIX@")
+  set(importLibraryName "assimp${ASSIMP_LIBRARY_SUFFIX}@CMAKE_DEBUG_POSTFIX@@CMAKE_IMPORT_LIBRARY_SUFFIX@")
+
+  # Import target "assimp::assimp" for configuration "Debug"
+  set_property(TARGET assimp::assimp APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG)
+  set_target_properties(assimp::assimp PROPERTIES
+    IMPORTED_IMPLIB_DEBUG "${_IMPORT_PREFIX}/lib/${importLibraryName}"
+    IMPORTED_LOCATION_DEBUG "${_IMPORT_PREFIX}/bin/${sharedLibraryName}"
+    ) 
+  list(APPEND _IMPORT_CHECK_TARGETS assimp::assimp )
+  list(APPEND _IMPORT_CHECK_FILES_FOR_assimp::assimp "${_IMPORT_PREFIX}/lib/${importLibraryName}")
+  list(APPEND _IMPORT_CHECK_FILES_FOR_assimp::assimp "${_IMPORT_PREFIX}/bin/${sharedLibraryName}" )
+
+else()
+  set(ASSIMP_LIBRARY_SUFFIX "@ASSIMP_LIBRARY_SUFFIX@" CACHE STRING "the suffix for the openrave libraries" )
+  set(sharedLibraryName "libassimp${ASSIMP_LIBRARY_SUFFIX}@CMAKE_DEBUG_POSTFIX@@CMAKE_SHARED_LIBRARY_SUFFIX@.@ASSIMP_VERSION_MAJOR@")
+  set_target_properties(assimp::assimp PROPERTIES
+    IMPORTED_SONAME_DEBUG "${sharedLibraryName}"
+    IMPORTED_LOCATION_DEBUG "${_IMPORT_PREFIX}/lib/${sharedLibraryName}"
+    )
+  list(APPEND _IMPORT_CHECK_TARGETS assimp::assimp )
+  list(APPEND _IMPORT_CHECK_FILES_FOR_assimp::assimp "${_IMPORT_PREFIX}/lib/${sharedLibraryName}" )
+endif()
+
+
+
+
+# Commands beyond this point should not need to know the version.
+set(CMAKE_IMPORT_FILE_VERSION)
+
+get_filename_component(ASSIMP_ROOT_DIR "@CMAKE_INSTALL_PREFIX@" REALPATH)
+set( ASSIMP_CXX_FLAGS ) # dynamically linked library
+set( ASSIMP_LINK_FLAGS "" )
+set( ASSIMP_LIBRARY_DIRS "${ASSIMP_ROOT_DIR}/@ASSIMP_LIB_INSTALL_DIR@")
+set( ASSIMP_INCLUDE_DIRS "${ASSIMP_ROOT_DIR}/@ASSIMP_INCLUDE_INSTALL_DIR@")
+set( ASSIMP_LIBRARIES ${sharedLibraryName})
+
+# for compatibility with pkg-config
+set(ASSIMP_CFLAGS_OTHER "${ASSIMP_CXX_FLAGS}")
+set(ASSIMP_LDFLAGS_OTHER "${ASSIMP_LINK_FLAGS}")
+
+MARK_AS_ADVANCED(
+  ASSIMP_ROOT_DIR
+  ASSIMP_CXX_FLAGS
+  ASSIMP_LINK_FLAGS
+  ASSIMP_INCLUDE_DIRS
+  ASSIMP_LIBRARIES
+  ASSIMP_CFLAGS_OTHER
+  ASSIMP_LDFLAGS_OTHER
+  ASSIMP_LIBRARY_SUFFIX
+)

assimpTargets-release.cmake.in

@@ -0,0 +1,75 @@
+#----------------------------------------------------------------
+# Generated CMake target import file for configuration "Release".
+#----------------------------------------------------------------
+
+# Commands may need to know the format version.
+set(CMAKE_IMPORT_FILE_VERSION 1)
+
+if(MSVC)
+  if( MSVC70 OR MSVC71 )
+    set(MSVC_PREFIX "vc70")
+  elseif( MSVC80 )
+    set(MSVC_PREFIX "vc80")
+  elseif( MSVC90 )
+    set(MSVC_PREFIX "vc90")
+  elseif( MSVC10 )
+    set(MSVC_PREFIX "vc100")
+  elseif( MSVC11 )
+    set(MSVC_PREFIX "vc110")
+  elseif( MSVC12 )
+    set(MSVC_PREFIX "vc120")
+  elseif( MSVC14 )
+    set(MSVC_PREFIX "vc140")
+  else()
+    set(MSVC_PREFIX "vc150")
+  endif()
+  set(ASSIMP_LIBRARY_SUFFIX "@ASSIMP_LIBRARY_SUFFIX@-${MSVC_PREFIX}-mt" CACHE STRING "the suffix for the assimp windows library" )
+
+  set(sharedLibraryName "assimp${ASSIMP_LIBRARY_SUFFIX}@CMAKE_SHARED_LIBRARY_SUFFIX@")
+  set(importLibraryName "assimp${ASSIMP_LIBRARY_SUFFIX}@CMAKE_IMPORT_LIBRARY_SUFFIX@")
+
+  # Import target "assimp::assimp" for configuration "Release"
+  set_property(TARGET assimp::assimp APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+  set_target_properties(assimp::assimp PROPERTIES
+    IMPORTED_IMPLIB_RELEASE "${_IMPORT_PREFIX}/lib/${importLibraryName}"
+    IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/bin/${sharedLibraryName}"
+    )
+  list(APPEND _IMPORT_CHECK_TARGETS assimp::assimp )
+  list(APPEND _IMPORT_CHECK_FILES_FOR_assimp::assimp "${_IMPORT_PREFIX}/lib/${importLibraryName}")
+  list(APPEND _IMPORT_CHECK_FILES_FOR_assimp::assimp "${_IMPORT_PREFIX}/bin/${sharedLibraryName}" )
+
+else()
+  set(ASSIMP_LIBRARY_SUFFIX "@ASSIMP_LIBRARY_SUFFIX@" CACHE STRING "the suffix for the openrave libraries" )
+  set(sharedLibraryName "libassimp${ASSIMP_LIBRARY_SUFFIX}@CMAKE_SHARED_LIBRARY_SUFFIX@.@ASSIMP_VERSION_MAJOR@")
+  set_target_properties(assimp::assimp PROPERTIES
+    IMPORTED_SONAME_RELEASE "${sharedLibraryName}"
+    IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib/${sharedLibraryName}"
+    )
+  list(APPEND _IMPORT_CHECK_TARGETS assimp::assimp )
+  list(APPEND _IMPORT_CHECK_FILES_FOR_assimp::assimp "${_IMPORT_PREFIX}/lib/${sharedLibraryName}" )
+endif()
+
+# Commands beyond this point should not need to know the version.
+set(CMAKE_IMPORT_FILE_VERSION)
+
+get_filename_component(ASSIMP_ROOT_DIR "@CMAKE_INSTALL_PREFIX@" REALPATH)
+set( ASSIMP_CXX_FLAGS ) # dynamically linked library
+set( ASSIMP_LINK_FLAGS "" )
+set( ASSIMP_LIBRARY_DIRS "${ASSIMP_ROOT_DIR}/@ASSIMP_LIB_INSTALL_DIR@")
+set( ASSIMP_INCLUDE_DIRS "${ASSIMP_ROOT_DIR}/@ASSIMP_INCLUDE_INSTALL_DIR@")
+set( ASSIMP_LIBRARIES ${sharedLibraryName})
+
+# for compatibility with pkg-config
+set(ASSIMP_CFLAGS_OTHER "${ASSIMP_CXX_FLAGS}")
+set(ASSIMP_LDFLAGS_OTHER "${ASSIMP_LINK_FLAGS}")
+
+MARK_AS_ADVANCED(
+  ASSIMP_ROOT_DIR
+  ASSIMP_CXX_FLAGS
+  ASSIMP_LINK_FLAGS
+  ASSIMP_INCLUDE_DIRS
+  ASSIMP_LIBRARIES
+  ASSIMP_CFLAGS_OTHER
+  ASSIMP_LDFLAGS_OTHER
+  ASSIMP_LIBRARY_SUFFIX
+)

assimpTargets.cmake.in

@@ -0,0 +1,101 @@
+# Generated by CMake
+
+if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.5)
+   message(FATAL_ERROR "CMake >= 2.6.0 required")
+endif()
+cmake_policy(PUSH)
+cmake_policy(VERSION 2.6)
+#----------------------------------------------------------------
+# Generated CMake target import file.
+#----------------------------------------------------------------
+
+# Commands may need to know the format version.
+set(CMAKE_IMPORT_FILE_VERSION 1)
+
+# Protect against multiple inclusion, which would fail when already imported targets are added once more.
+set(_targetsDefined)
+set(_targetsNotDefined)
+set(_expectedTargets)
+foreach(_expectedTarget assimp::assimp)
+  list(APPEND _expectedTargets ${_expectedTarget})
+  if(NOT TARGET ${_expectedTarget})
+    list(APPEND _targetsNotDefined ${_expectedTarget})
+  endif()
+  if(TARGET ${_expectedTarget})
+    list(APPEND _targetsDefined ${_expectedTarget})
+  endif()
+endforeach()
+if("${_targetsDefined}" STREQUAL "${_expectedTargets}")
+  unset(_targetsDefined)
+  unset(_targetsNotDefined)
+  unset(_expectedTargets)
+  set(CMAKE_IMPORT_FILE_VERSION)
+  cmake_policy(POP)
+  return()
+endif()
+if(NOT "${_targetsDefined}" STREQUAL "")
+  message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_targetsDefined}\nTargets not yet defined: ${_targetsNotDefined}\n")
+endif()
+unset(_targetsDefined)
+unset(_targetsNotDefined)
+unset(_expectedTargets)
+
+
+# Compute the installation prefix relative to this file.
+get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH)
+get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH)
+get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH)
+get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH)
+if(_IMPORT_PREFIX STREQUAL "/")
+  set(_IMPORT_PREFIX "")
+endif()
+
+# Create imported target assimp::assimp
+add_library(assimp::assimp SHARED IMPORTED)
+
+set_target_properties(assimp::assimp PROPERTIES
+  COMPATIBLE_INTERFACE_STRING "assimp_MAJOR_VERSION"
+  INTERFACE_assimp_MAJOR_VERSION "1"
+  INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include;${_IMPORT_PREFIX}/include"
+  #INTERFACE_LINK_LIBRARIES "TxtUtils::TxtUtils;MealyMachine::MealyMachine"
+)
+
+if(CMAKE_VERSION VERSION_LESS 2.8.12)
+  message(FATAL_ERROR "This file relies on consumers using CMake 2.8.12 or greater.")
+endif()
+
+# Load information for each installed configuration.
+get_filename_component(_DIR "${CMAKE_CURRENT_LIST_FILE}" PATH)
+file(GLOB CONFIG_FILES "${_DIR}/assimpTargets-*.cmake")
+foreach(f ${CONFIG_FILES})
+  include(${f})
+endforeach()
+
+# Cleanup temporary variables.
+set(_IMPORT_PREFIX)
+
+# Loop over all imported files and verify that they actually exist
+foreach(target ${_IMPORT_CHECK_TARGETS} )
+  foreach(file ${_IMPORT_CHECK_FILES_FOR_${target}} )
+    if(NOT EXISTS "${file}" )
+      message(FATAL_ERROR "The imported target \"${target}\" references the file
+   \"${file}\"
+but this file does not exist.  Possible reasons include:
+* The file was deleted, renamed, or moved to another location.
+* An install or uninstall procedure did not complete successfully.
+* The installation package was faulty and contained
+   \"${CMAKE_CURRENT_LIST_FILE}\"
+but not all the files it references.
+")
+    endif()
+  endforeach()
+  unset(_IMPORT_CHECK_FILES_FOR_${target})
+endforeach()
+unset(_IMPORT_CHECK_TARGETS)
+
+# This file does not depend on other imported targets which have
+# been exported from the same project but in a separate export set.
+
+# Commands beyond this point should not need to know the version.
+set(CMAKE_IMPORT_FILE_VERSION)
+cmake_policy(POP)

code/3DSHelper.h

@@ -58,7 +58,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 namespace Assimp    {
 namespace D3DS  {
 
-#include "./../include/assimp/Compiler/pushpack1.h"
+#include <assimp/Compiler/pushpack1.h>
 
 // ---------------------------------------------------------------------------
 /** Discreet3DS class: Helper class for loading 3ds files. Defines chunks
@@ -66,7 +66,7 @@ namespace D3DS  {
 */
 class Discreet3DS {
 private:
-    Discreet3DS() {
+    Discreet3DS() AI_NO_EXCEPT {
         // empty
     }
 
@@ -328,19 +328,17 @@ struct Face : public FaceWithSmoothingGroup
 
 // ---------------------------------------------------------------------------
 /** Helper structure representing a texture */
-struct Texture
-{
+struct Texture {
     //! Default constructor
-    Texture()
-        : mOffsetU  (0.0)
-        , mOffsetV  (0.0)
-        , mScaleU   (1.0)
-        , mScaleV   (1.0)
-        , mRotation (0.0)
-        , mMapMode  (aiTextureMapMode_Wrap)
-        , bPrivate()
-        , iUVSrc    (0)
-    {
+    Texture() AI_NO_EXCEPT
+    : mOffsetU  (0.0)
+    , mOffsetV  (0.0)
+    , mScaleU   (1.0)
+    , mScaleV   (1.0)
+    , mRotation (0.0)
+    , mMapMode  (aiTextureMapMode_Wrap)
+    , bPrivate()
+    , iUVSrc    (0) {
         mTextureBlend = get_qnan();
     }
 
@@ -365,7 +363,7 @@ struct Texture
     int iUVSrc;
 };
 
-#include "./../include/assimp/Compiler/poppack1.h"
+#include <assimp/Compiler/poppack1.h>
 
 // ---------------------------------------------------------------------------
 /** Helper structure representing a 3ds material */
@@ -394,7 +392,7 @@ struct Material
 
 
     //! Move constructor. This is explicitly written because MSVC doesn't support defaulting it
-    Material(Material &&other)
+    Material(Material &&other) AI_NO_EXCEPT
     : mName(std::move(other.mName))
     , mDiffuse(std::move(other.mDiffuse))
     , mSpecularExponent(std::move(other.mSpecularExponent))
@@ -418,7 +416,7 @@ struct Material
     }
 
 
-    Material &operator=(Material &&other) {
+    Material &operator=(Material &&other) AI_NO_EXCEPT {
         if (this == &other) {
             return *this;
         }
@@ -447,7 +445,7 @@ struct Material
     }
 
 
-    ~Material() {}
+    virtual ~Material() {}
 
 
     //! Name of the material

code/3DSLoader.cpp

@@ -161,19 +161,21 @@ void Discreet3DSImporter::InternReadFile( const std::string& pFile,
     aiScene* pScene, IOSystem* pIOHandler)
 {
     StreamReaderLE stream(pIOHandler->Open(pFile,"rb"));
-    this->stream = &stream;
 
     // We should have at least one chunk
     if (stream.GetRemainingSize() < 16) {
         throw DeadlyImportError("3DS file is either empty or corrupt: " + pFile);
     }
+    this->stream = &stream;
 
     // Allocate our temporary 3DS representation
-    mScene = new D3DS::Scene();
+    D3DS::Scene _scene;
+    mScene = &_scene;
 
     // Initialize members
+    D3DS::Node _rootNode("UNNAMED");
     mLastNodeIndex             = -1;
-    mCurrentNode               = new D3DS::Node("UNNAMED");
+    mCurrentNode               = &_rootNode;
     mRootNode                  = mCurrentNode;
     mRootNode->mHierarchyPos   = -1;
     mRootNode->mHierarchyIndex = -1;
@@ -193,7 +195,6 @@ void Discreet3DSImporter::InternReadFile( const std::string& pFile,
     // file.
     for (auto &mesh : mScene->mMeshes) {
         if (mesh.mFaces.size() > 0 && mesh.mPositions.size() == 0)  {
-            delete mScene;
             throw DeadlyImportError("3DS file contains faces but no vertices: " + pFile);
         }
         CheckIndices(mesh);
@@ -201,7 +202,7 @@ void Discreet3DSImporter::InternReadFile( const std::string& pFile,
         ComputeNormalsWithSmoothingsGroups<D3DS::Face>(mesh);
     }
 
-    // Replace all occurrences of the default material with a
+    // Replace all occurences of the default material with a
     // valid material. Generate it if no material containing
     // DEFAULT in its name has been found in the file
     ReplaceDefaultMaterial();
@@ -218,10 +219,8 @@ void Discreet3DSImporter::InternReadFile( const std::string& pFile,
     // Now apply the master scaling factor to the scene
     ApplyMasterScale(pScene);
 
-    // Delete our internal scene representation and the root
-    // node, so the whole hierarchy will follow
-    delete mRootNode;
-    delete mScene;
+    // Our internal scene representation and the root
+    // node will be automatically deleted, so the whole hierarchy will follow
 
     AI_DEBUG_INVALIDATE_PTR(mRootNode);
     AI_DEBUG_INVALIDATE_PTR(mScene);

code/AMFImporter.hpp

@@ -63,8 +63,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 // Header files, stdlib.
 #include <set>
 
-namespace Assimp
-{
+namespace Assimp {
+
 /// \class AMFImporter
 /// Class that holding scene graph which include: geometry, metadata, materials etc.
 ///
@@ -99,100 +99,49 @@ namespace Assimp
 ///            new - <texmap> and children <utex1>, <utex2>, <utex3>, <vtex1>, <vtex2>, <vtex3>
 ///            old - <map> and children <u1>, <u2>, <u3>, <v1>, <v2>, <v3>
 ///
-class AMFImporter : public BaseImporter
-{
-	/***********************************************/
-	/******************** Types ********************/
-	/***********************************************/
-
+class AMFImporter : public BaseImporter {
 private:
+    struct SPP_Material;// forward declaration
+
+                        /// \struct SPP_Composite
+                        /// Data type for post-processing step. More suitable container for part of material's composition.
+    struct SPP_Composite {
+        SPP_Material* Material;///< Pointer to material - part of composition.
+        std::string Formula;///< Formula for calculating ratio of \ref Material.
+    };
+
+    /// \struct SPP_Material
+    /// Data type for post-processing step. More suitable container for material.
+    struct SPP_Material {
+        std::string ID;///< Material ID.
+        std::list<CAMFImporter_NodeElement_Metadata*> Metadata;///< Metadata of material.
+        CAMFImporter_NodeElement_Color* Color;///< Color of material.
+        std::list<SPP_Composite> Composition;///< List of child materials if current material is composition of few another.
+
+        /// Return color calculated for specified coordinate.
+        /// \param [in] pX - "x" coordinate.
+        /// \param [in] pY - "y" coordinate.
+        /// \param [in] pZ - "z" coordinate.
+        /// \return calculated color.
+        aiColor4D GetColor(const float pX, const float pY, const float pZ) const;
+    };
+
+    /// Data type for post-processing step. More suitable container for texture.
+    struct SPP_Texture {
+        std::string ID;
+        size_t      Width, Height, Depth;
+        bool        Tiled;
+        char        FormatHint[9];// 8 for string + 1 for terminator.
+        uint8_t    *Data;
+    };
+
+    /// Data type for post-processing step. Contain face data.
+    struct SComplexFace {
+        aiFace Face;///< Face vertices.
+        const CAMFImporter_NodeElement_Color* Color;///< Face color. Equal to nullptr if color is not set for the face.
+        const CAMFImporter_NodeElement_TexMap* TexMap;///< Face texture mapping data. Equal to nullptr if texture mapping is not set for the face.
+    };
 
-	struct SPP_Material;// forward declaration
-
-	/// \struct SPP_Composite
-	/// Data type for postprocessing step. More suitable container for part of material's composition.
-	struct SPP_Composite
-	{
-		SPP_Material* Material;///< Pointer to material - part of composition.
-		std::string Formula;///< Formula for calculating ratio of \ref Material.
-	};
-
-	/// \struct SPP_Material
-	/// Data type for postprocessing step. More suitable container for material.
-	struct SPP_Material
-	{
-		std::string ID;///< Material ID.
-		std::list<CAMFImporter_NodeElement_Metadata*> Metadata;///< Metadata of material.
-		CAMFImporter_NodeElement_Color* Color;///< Color of material.
-		std::list<SPP_Composite> Composition;///< List of child materials if current material is composition of few another.
-
-		/// \fn aiColor4D GetColor(const float pX, const float pY, const float pZ) const
-		/// Return color calculated for specified coordinate.
-		/// \param [in] pX - "x" coordinate.
-		/// \param [in] pY - "y" coordinate.
-		/// \param [in] pZ - "z" coordinate.
-		/// \return calculated color.
-		aiColor4D GetColor(const float pX, const float pY, const float pZ) const;
-	};
-
-	/// \struct SPP_Texture
-	/// Data type for post-processing step. More suitable container for texture.
-	struct SPP_Texture
-	{
-		std::string ID;
-		size_t      Width, Height, Depth;
-		bool        Tiled;
-        char        FormatHint[ 9 ];// 8 for string + 1 for terminator.
-		uint8_t    *Data;
-	};
-
-	///	\struct SComplexFace
-	/// Data type for post-processing step. Contain face data.
-	struct SComplexFace
-	{
-		aiFace Face;///< Face vertices.
-		const CAMFImporter_NodeElement_Color* Color;///< Face color. Equal to nullptr if color is not set for the face.
-		const CAMFImporter_NodeElement_TexMap* TexMap;///< Face texture mapping data. Equal to nullptr if texture mapping is not set for the face.
-	};
-
-
-
-	/***********************************************/
-	/****************** Constants ******************/
-	/***********************************************/
-
-private:
-
-	static const aiImporterDesc Description;
-
-	/***********************************************/
-	/****************** Variables ******************/
-	/***********************************************/
-
-private:
-
-    CAMFImporter_NodeElement* mNodeElement_Cur;///< Current element.
-    std::list<CAMFImporter_NodeElement*> mNodeElement_List;///< All elements of scene graph.
-	irr::io::IrrXMLReader* mReader;///< Pointer to XML-reader object
-	std::string mUnit;
-	std::list<SPP_Material> mMaterial_Converted;///< List of converted materials for postprocessing step.
-	std::list<SPP_Texture> mTexture_Converted;///< List of converted textures for postprocessing step.
-
-	/***********************************************/
-	/****************** Functions ******************/
-	/***********************************************/
-
-private:
-
-	/// \fn AMFImporter(const AMFImporter& pScene)
-	/// Disabled copy constructor.
-	AMFImporter(const AMFImporter& pScene);
-
-	/// \fn AMFImporter& operator=(const AMFImporter& pScene)
-	/// Disabled assign operator.
-	AMFImporter& operator=(const AMFImporter& pScene);
-
-	/// \fn void Clear()
 	/// Clear all temporary data.
 	void Clear();
 
@@ -200,7 +149,6 @@ private:
 	/************* Functions: find set *************/
 	/***********************************************/
 
-	/// \fn bool Find_NodeElement(const std::string& pID, const CAMFImporter_NodeElement::EType pType, aiNode** pNode) const
 	/// Find specified node element in node elements list ( \ref mNodeElement_List).
 	/// \param [in] pID - ID(name) of requested node element.
 	/// \param [in] pType - type of node element.
@@ -208,7 +156,6 @@ private:
 	/// \return true - if the node element is found, else - false.
 	bool Find_NodeElement(const std::string& pID, const CAMFImporter_NodeElement::EType pType, CAMFImporter_NodeElement** pNodeElement) const;
 
-	/// \fn bool Find_ConvertedNode(const std::string& pID, std::list<aiNode*>& pNodeList, aiNode** pNode) const
 	/// Find requested aiNode in node list.
 	/// \param [in] pID - ID(name) of requested node.
 	/// \param [in] pNodeList - list of nodes where to find the node.
@@ -216,15 +163,13 @@ private:
 	/// \return true - if the node is found, else - false.
 	bool Find_ConvertedNode(const std::string& pID, std::list<aiNode*>& pNodeList, aiNode** pNode) const;
 
-	/// \fn bool Find_ConvertedMaterial(const std::string& pID, const SPP_Material** pConvertedMaterial) const
 	/// Find material in list for converted materials. Use at postprocessing step.
 	/// \param [in] pID - material ID.
 	/// \param [out] pConvertedMaterial - pointer to found converted material (\ref SPP_Material).
 	/// \return true - if the material is found, else - false.
 	bool Find_ConvertedMaterial(const std::string& pID, const SPP_Material** pConvertedMaterial) const;
 
-	/// \fn bool Find_ConvertedTexture(const std::string& pID_R, const std::string& pID_G, const std::string& pID_B, const std::string& pID_A, uint32_t* pConvertedTextureIndex = nullptr) const
-	/// Find texture in list of converted textures. Use at postprocessing step,
+    /// Find texture in list of converted textures. Use at postprocessing step,
 	/// \param [in] pID_R - ID of source "red" texture.
 	/// \param [in] pID_G - ID of source "green" texture.
 	/// \param [in] pID_B - ID of source "blue" texture.
@@ -235,11 +180,7 @@ private:
 	bool Find_ConvertedTexture(const std::string& pID_R, const std::string& pID_G, const std::string& pID_B, const std::string& pID_A,
 								uint32_t* pConvertedTextureIndex = nullptr) const;
 
-	/***********************************************/
-	/********* Functions: postprocess set **********/
-	/***********************************************/
 
-	/// \fn void PostprocessHelper_CreateMeshDataArray(const CAMFImporter_NodeElement_Mesh& pNodeElement, std::vector<aiVector3D>& pVertexCoordinateArray, std::vector<CAMFImporter_NodeElement_Color*>& pVertexColorArray) const
 	/// Get data stored in <vertices> and place it to arrays.
 	/// \param [in] pNodeElement - reference to node element which kept <object> data.
 	/// \param [in] pVertexCoordinateArray - reference to vertices coordinates kept in <vertices>.
@@ -248,7 +189,6 @@ private:
 	void PostprocessHelper_CreateMeshDataArray(const CAMFImporter_NodeElement_Mesh& pNodeElement, std::vector<aiVector3D>& pVertexCoordinateArray,
 												std::vector<CAMFImporter_NodeElement_Color*>& pVertexColorArray) const;
 
-	/// \fn size_t PostprocessHelper_GetTextureID_Or_Create(const std::string& pID_R, const std::string& pID_G, const std::string& pID_B, const std::string& pID_A)
 	/// Return converted texture ID which related to specified source textures ID's. If converted texture does not exist then it will be created and ID on new
 	/// converted texture will be returned. Conversion: set of textures from \ref CAMFImporter_NodeElement_Texture to one \ref SPP_Texture and place it
 	/// to converted textures list.
@@ -260,27 +200,23 @@ private:
 	/// \return index of the texture in array of the converted textures.
 	size_t PostprocessHelper_GetTextureID_Or_Create(const std::string& pID_R, const std::string& pID_G, const std::string& pID_B, const std::string& pID_A);
 
-	/// \fn void PostprocessHelper_SplitFacesByTextureID(std::list<SComplexFace>& pInputList, std::list<std::list<SComplexFace> > pOutputList_Separated)
 	/// Separate input list by texture IDs. This step is needed because aiMesh can contain mesh which is use only one texture (or set: diffuse, bump etc).
 	/// \param [in] pInputList - input list with faces. Some of them can contain color or texture mapping, or both of them, or nothing. Will be cleared after
 	/// processing.
 	/// \param [out] pOutputList_Separated - output list of the faces lists. Separated faces list by used texture IDs. Will be cleared before processing.
 	void PostprocessHelper_SplitFacesByTextureID(std::list<SComplexFace>& pInputList, std::list<std::list<SComplexFace> >& pOutputList_Separated);
 
-	/// \fn void Postprocess_AddMetadata(const std::list<CAMFImporter_NodeElement_Metadata*>& pMetadataList, aiNode& pSceneNode) const
 	/// Check if child elements of node element is metadata and add it to scene node.
 	/// \param [in] pMetadataList - reference to list with collected metadata.
 	/// \param [out] pSceneNode - scene node in which metadata will be added.
 	void Postprocess_AddMetadata(const std::list<CAMFImporter_NodeElement_Metadata*>& pMetadataList, aiNode& pSceneNode) const;
 
-	/// \fn void Postprocess_BuildNodeAndObject(const CAMFImporter_NodeElement_Object& pNodeElement, std::list<aiMesh*>& pMeshList, aiNode** pSceneNode)
 	/// To create aiMesh and aiNode for it from <object>.
 	/// \param [in] pNodeElement - reference to node element which kept <object> data.
 	/// \param [out] pMeshList - reference to a list with all aiMesh of the scene.
 	/// \param [out] pSceneNode - pointer to place where new aiNode will be created.
 	void Postprocess_BuildNodeAndObject(const CAMFImporter_NodeElement_Object& pNodeElement, std::list<aiMesh*>& pMeshList, aiNode** pSceneNode);
 
-	/// \fn void Postprocess_BuildMeshSet(const CAMFImporter_NodeElement_Mesh& pNodeElement, const std::vector<aiVector3D>& pVertexCoordinateArray, const std::vector<CAMFImporter_NodeElement_Color*>& pVertexColorArray, const CAMFImporter_NodeElement_Color* pObjectColor, std::list<aiMesh*>& pMeshList, aiNode& pSceneNode)
 	/// Create mesh for every <volume> in <mesh>.
 	/// \param [in] pNodeElement - reference to node element which kept <mesh> data.
 	/// \param [in] pVertexCoordinateArray - reference to vertices coordinates for all <volume>'s.
@@ -294,27 +230,20 @@ private:
 									const std::vector<CAMFImporter_NodeElement_Color*>& pVertexColorArray, const CAMFImporter_NodeElement_Color* pObjectColor,
 									std::list<aiMesh*>& pMeshList, aiNode& pSceneNode);
 
-	/// \fn void Postprocess_BuildMaterial(const CAMFImporter_NodeElement_Material& pMaterial)
 	/// Convert material from \ref CAMFImporter_NodeElement_Material to \ref SPP_Material.
 	/// \param [in] pMaterial - source CAMFImporter_NodeElement_Material.
 	void Postprocess_BuildMaterial(const CAMFImporter_NodeElement_Material& pMaterial);
 
-	/// \fn void Postprocess_BuildConstellation(CAMFImporter_NodeElement_Constellation& pConstellation, std::list<aiNode*>& pNodeList) const
 	/// Create and add to aiNode's list new part of scene graph defined by <constellation>.
 	/// \param [in] pConstellation - reference to <constellation> node.
 	/// \param [out] pNodeList - reference to aiNode's list.
 	void Postprocess_BuildConstellation(CAMFImporter_NodeElement_Constellation& pConstellation, std::list<aiNode*>& pNodeList) const;
 
-	/// \fn void Postprocess_BuildScene()
 	/// Build Assimp scene graph in aiScene from collected data.
 	/// \param [out] pScene - pointer to aiScene where tree will be built.
 	void Postprocess_BuildScene(aiScene* pScene);
 
-	/***********************************************/
-	/************* Functions: throw set ************/
-	/***********************************************/
 
-	/// \fn void Throw_CloseNotFound(const std::string& pNode)
 	/// Call that function when close tag of node not found and exception must be raised.
 	/// E.g.:
 	/// <amf>
@@ -324,19 +253,16 @@ private:
 	/// \param [in] pNode - node name in which exception happened.
 	void Throw_CloseNotFound(const std::string& pNode);
 
-	/// \fn void Throw_IncorrectAttr(const std::string& pAttrName)
 	/// Call that function when attribute name is incorrect and exception must be raised.
 	/// \param [in] pAttrName - attribute name.
 	/// \throw DeadlyImportError.
 	void Throw_IncorrectAttr(const std::string& pAttrName);
 
-	/// \fn void Throw_IncorrectAttrValue(const std::string& pAttrName)
 	/// Call that function when attribute value is incorrect and exception must be raised.
 	/// \param [in] pAttrName - attribute name.
 	/// \throw DeadlyImportError.
 	void Throw_IncorrectAttrValue(const std::string& pAttrName);
 
-	/// \fn void Throw_MoreThanOnceDefined(const std::string& pNode, const std::string& pDescription)
 	/// Call that function when some type of nodes are defined twice or more when must be used only once and exception must be raised.
 	/// E.g.:
 	/// <object>
@@ -348,204 +274,158 @@ private:
 	/// \param [in] pDescription - message about error. E.g. what the node defined while exception raised.
 	void Throw_MoreThanOnceDefined(const std::string& pNodeType, const std::string& pDescription);
 
-	/// \fn void Throw_ID_NotFound(const std::string& pID) const
 	/// Call that function when referenced element ID are not found in graph and exception must be raised.
 	/// \param [in] pID - ID of of element which not found.
 	/// \throw DeadlyImportError.
 	void Throw_ID_NotFound(const std::string& pID) const;
 
-	/***********************************************/
-	/************** Functions: LOG set *************/
-	/***********************************************/
-
-	/***********************************************/
-	/************** Functions: XML set *************/
-	/***********************************************/
-
-	/// \fn void XML_CheckNode_MustHaveChildren()
 	/// Check if current node have children: <node>...</node>. If not then exception will throwed.
 	void XML_CheckNode_MustHaveChildren();
 
-	/// \fn bool XML_CheckNode_NameEqual(const std::string& pNodeName)
 	/// Check if current node name is equal to pNodeName.
 	/// \param [in] pNodeName - name for checking.
 	/// return true if current node name is equal to pNodeName, else - false.
 	bool XML_CheckNode_NameEqual(const std::string& pNodeName) { return mReader->getNodeName() == pNodeName; }
 
-	/// \fn void XML_CheckNode_SkipUnsupported(const std::string& pParentNodeName)
 	/// Skip unsupported node and report about that. Depend on node name can be skipped begin tag of node all whole node.
 	/// \param [in] pParentNodeName - parent node name. Used for reporting.
 	void XML_CheckNode_SkipUnsupported(const std::string& pParentNodeName);
 
-	/// \fn bool XML_SearchNode(const std::string& pNodeName)
 	/// Search for specified node in file. XML file read pointer(mReader) will point to found node or file end after search is end.
 	/// \param [in] pNodeName - requested node name.
 	/// return true - if node is found, else - false.
 	bool XML_SearchNode(const std::string& pNodeName);
 
-	/// \fn bool XML_ReadNode_GetAttrVal_AsBool(const int pAttrIdx)
 	/// Read attribute value.
 	/// \param [in] pAttrIdx - attribute index (\ref mReader->getAttribute* set).
 	/// \return read data.
 	bool XML_ReadNode_GetAttrVal_AsBool(const int pAttrIdx);
 
-	/// \fn float XML_ReadNode_GetAttrVal_AsFloat(const int pAttrIdx)
 	/// Read attribute value.
 	/// \param [in] pAttrIdx - attribute index (\ref mReader->getAttribute* set).
 	/// \return read data.
 	float XML_ReadNode_GetAttrVal_AsFloat(const int pAttrIdx);
 
-	/// \fn uint32_t XML_ReadNode_GetAttrVal_AsU32(const int pAttrIdx)
 	/// Read attribute value.
 	/// \param [in] pAttrIdx - attribute index (\ref mReader->getAttribute* set).
 	/// \return read data.
 	uint32_t XML_ReadNode_GetAttrVal_AsU32(const int pAttrIdx);
 
-	/// \fn float XML_ReadNode_GetVal_AsFloat()
 	/// Read node value.
 	/// \return read data.
 	float XML_ReadNode_GetVal_AsFloat();
 
-	/// \fn uint32_t XML_ReadNode_GetVal_AsU32()
 	/// Read node value.
 	/// \return read data.
 	uint32_t XML_ReadNode_GetVal_AsU32();
 
-	/// \fn void XML_ReadNode_GetVal_AsString(std::string& pValue)
 	/// Read node value.
 	/// \return read data.
 	void XML_ReadNode_GetVal_AsString(std::string& pValue);
 
-	/***********************************************/
-	/******** Functions: parse set private *********/
-	/***********************************************/
-
-	/// \fn void ParseHelper_Node_Enter(CAMFImporter_NodeElement* pNode)
 	/// Make pNode as current and enter deeper for parsing child nodes. At end \ref ParseHelper_Node_Exit must be called.
 	/// \param [in] pNode - new current node.
 	void ParseHelper_Node_Enter(CAMFImporter_NodeElement* pNode);
 
-	/// \fn void ParseHelper_Group_End()
 	/// This function must be called when exiting from grouping node. \ref ParseHelper_Group_Begin.
 	void ParseHelper_Node_Exit();
 
-	/// \fn void ParseHelper_FixTruncatedFloatString(const char* pInStr, std::string& pOutString)
 	/// Attribute values of floating point types can take form ".x"(without leading zero). irrXMLReader can not read this form of values and it
 	/// must be converted to right form - "0.xxx".
 	/// \param [in] pInStr - pointer to input string which can contain incorrect form of values.
 	/// \param [out[ pOutString - output string with right form of values.
 	void ParseHelper_FixTruncatedFloatString(const char* pInStr, std::string& pOutString);
 
-	/// \fn void ParseHelper_Decode_Base64(const std::string& pInputBase64, std::vector<uint8_t>& pOutputData) const
 	/// Decode Base64-encoded data.
 	/// \param [in] pInputBase64 - reference to input Base64-encoded string.
 	/// \param [out] pOutputData - reference to output array for decoded data.
 	void ParseHelper_Decode_Base64(const std::string& pInputBase64, std::vector<uint8_t>& pOutputData) const;
 
-	/// \fn void ParseNode_Root()
 	/// Parse <AMF> node of the file.
 	void ParseNode_Root();
 
-	/******** Functions: top nodes *********/
-
-	/// \fn void ParseNode_Constellation()
 	/// Parse <constellation> node of the file.
 	void ParseNode_Constellation();
 
-	/// \fn void ParseNode_Constellation()
 	/// Parse <instance> node of the file.
 	void ParseNode_Instance();
 
-	/// \fn void ParseNode_Material()
 	/// Parse <material> node of the file.
 	void ParseNode_Material();
 
-	/// \fn void ParseNode_Metadata()
 	/// Parse <metadata> node.
 	void ParseNode_Metadata();
 
-	/// \fn void ParseNode_Object()
 	/// Parse <object> node of the file.
 	void ParseNode_Object();
 
-	/// \fn void ParseNode_Texture()
 	/// Parse <texture> node of the file.
 	void ParseNode_Texture();
 
-	/******** Functions: geometry nodes *********/
-
-	/// \fn void ParseNode_Coordinates()
 	/// Parse <coordinates> node of the file.
 	void ParseNode_Coordinates();
 
-	/// \fn void ParseNode_Edge()
 	/// Parse <edge> node of the file.
 	void ParseNode_Edge();
 
-	/// \fn void ParseNode_Mesh()
 	/// Parse <mesh> node of the file.
 	void ParseNode_Mesh();
 
-	/// \fn void ParseNode_Triangle()
 	/// Parse <triangle> node of the file.
 	void ParseNode_Triangle();
 
-	/// \fn void ParseNode_Vertex()
 	/// Parse <vertex> node of the file.
 	void ParseNode_Vertex();
 
-	/// \fn void ParseNode_Vertices()
 	/// Parse <vertices> node of the file.
 	void ParseNode_Vertices();
 
-	/// \fn void ParseNode_Volume()
 	/// Parse <volume> node of the file.
 	void ParseNode_Volume();
 
-	/******** Functions: material nodes *********/
-
-	/// \fn void ParseNode_Color()
 	/// Parse <color> node of the file.
 	void ParseNode_Color();
 
-	/// \fn void ParseNode_TexMap(const bool pUseOldName = false)
 	/// Parse <texmap> of <map> node of the file.
 	/// \param [in] pUseOldName - if true then use old name of node(and children) - <map>, instead of new name - <texmap>.
 	void ParseNode_TexMap(const bool pUseOldName = false);
 
 public:
-
-	/// \fn AMFImporter()
 	/// Default constructor.
-	AMFImporter()
-		: mNodeElement_Cur(nullptr), mReader(nullptr)
-	{}
+	AMFImporter() AI_NO_EXCEPT
+    : mNodeElement_Cur(nullptr)
+    , mReader(nullptr) {
+        // empty
+    }
 
-	/// \fn ~AMFImporter()
 	/// Default destructor.
 	~AMFImporter();
 
-	/***********************************************/
-	/******** Functions: parse set, public *********/
-	/***********************************************/
-
-	/// \fn void ParseFile(const std::string& pFile, IOSystem* pIOHandler)
 	/// Parse AMF file and fill scene graph. The function has no return value. Result can be found by analyzing the generated graph.
-	/// Also exception can be throwed if trouble will found.
+	/// Also exception can be thrown if trouble will found.
 	/// \param [in] pFile - name of file to be parsed.
 	/// \param [in] pIOHandler - pointer to IO helper object.
 	void ParseFile(const std::string& pFile, IOSystem* pIOHandler);
 
-	/***********************************************/
-	/********* Functions: BaseImporter set *********/
-	/***********************************************/
-
 	bool CanRead(const std::string& pFile, IOSystem* pIOHandler, bool pCheckSig) const;
 	void GetExtensionList(std::set<std::string>& pExtensionList);
 	void InternReadFile(const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler);
 	const aiImporterDesc* GetInfo ()const;
 
-};// class AMFImporter
+    AMFImporter(const AMFImporter& pScene) = delete;
+    AMFImporter& operator=(const AMFImporter& pScene) = delete;
+
+private:
+    static const aiImporterDesc Description;
+
+    CAMFImporter_NodeElement* mNodeElement_Cur;///< Current element.
+    std::list<CAMFImporter_NodeElement*> mNodeElement_List;///< All elements of scene graph.
+    irr::io::IrrXMLReader* mReader;///< Pointer to XML-reader object
+    std::string mUnit;
+    std::list<SPP_Material> mMaterial_Converted;///< List of converted materials for postprocessing step.
+    std::list<SPP_Texture> mTexture_Converted;///< List of converted textures for postprocessing step.
+
+};
 
 }// namespace Assimp
 

code/AMFImporter_Material.cpp

@@ -68,10 +68,9 @@ namespace Assimp
 //   Multi elements - No.
 //   Red, Greed, Blue and Alpha (transparency) component of a color in sRGB space, values ranging from 0 to 1. The
 //   values can be specified as constants, or as a formula depending on the coordinates.
-void AMFImporter::ParseNode_Color()
-{
-std::string profile;
-CAMFImporter_NodeElement* ne;
+void AMFImporter::ParseNode_Color() {
+    std::string profile;
+    CAMFImporter_NodeElement* ne;
 
 	// Read attributes for node <color>.
 	MACRO_ATTRREAD_LOOPBEG;
@@ -98,15 +97,19 @@ CAMFImporter_NodeElement* ne;
 		MACRO_NODECHECK_LOOPEND("color");
 		ParseHelper_Node_Exit();
 		// check that all components was defined
-		if(!(read_flag[0] && read_flag[1] && read_flag[2])) throw DeadlyImportError("Not all color components are defined.");
-		// check if <a> is absent. Then manually add "a == 1".
-		if(!read_flag[3]) als.Color.a = 1;
-
-	}// if(!mReader->isEmptyElement())
+        if (!(read_flag[0] && read_flag[1] && read_flag[2])) {
+            throw DeadlyImportError("Not all color components are defined.");
+        }
+
+        // check if <a> is absent. Then manually add "a == 1".
+        if (!read_flag[3]) {
+            als.Color.a = 1;
+        }
+	}
 	else
 	{
 		mNodeElement_Cur->Child.push_back(ne);// Add element to child list of current element
-	}// if(!mReader->isEmptyElement()) else
+	}
 
 	als.Composed = false;
 	mNodeElement_List.push_back(ne);// and to node element list because its a new object in graph.
@@ -119,10 +122,9 @@ CAMFImporter_NodeElement* ne;
 // An available material.
 // Multi elements - Yes.
 // Parent element - <amf>.
-void AMFImporter::ParseNode_Material()
-{
-std::string id;
-CAMFImporter_NodeElement* ne;
+void AMFImporter::ParseNode_Material() {
+    std::string id;
+    CAMFImporter_NodeElement* ne;
 
 	// Read attributes for node <color>.
 	MACRO_ATTRREAD_LOOPBEG;
@@ -131,9 +133,11 @@ CAMFImporter_NodeElement* ne;
 
 	// create new object.
 	ne = new CAMFImporter_NodeElement_Material(mNodeElement_Cur);
-	// and assign read data
+
+    // and assign read data
 	((CAMFImporter_NodeElement_Material*)ne)->ID = id;
-	// Check for child nodes
+
+    // Check for child nodes
 	if(!mReader->isEmptyElement())
 	{
 		bool col_read = false;
@@ -154,11 +158,11 @@ CAMFImporter_NodeElement* ne;
 			if(XML_CheckNode_NameEqual("metadata")) { ParseNode_Metadata(); continue; }
 		MACRO_NODECHECK_LOOPEND("material");
 		ParseHelper_Node_Exit();
-	}// if(!mReader->isEmptyElement())
+	}
 	else
 	{
 		mNodeElement_Cur->Child.push_back(ne);// Add element to child list of current element
-	}// if(!mReader->isEmptyElement()) else
+	}
 
 	mNodeElement_List.push_back(ne);// and to node element list because its a new object in graph.
 }
@@ -181,14 +185,13 @@ CAMFImporter_NodeElement* ne;
 // Parent element - <amf>.
 void AMFImporter::ParseNode_Texture()
 {
-std::string id;
-uint32_t width = 0;
-uint32_t height = 0;
-uint32_t depth = 1;
-std::string type;
-bool tiled = false;
-std::string enc64_data;
-CAMFImporter_NodeElement* ne;
+    std::string id;
+    uint32_t width = 0;
+    uint32_t height = 0;
+    uint32_t depth = 1;
+    std::string type;
+    bool tiled = false;
+    std::string enc64_data;
 
 	// Read attributes for node <color>.
 	MACRO_ATTRREAD_LOOPBEG;
@@ -201,20 +204,34 @@ CAMFImporter_NodeElement* ne;
 	MACRO_ATTRREAD_LOOPEND;
 
 	// create new texture object.
-	ne = new CAMFImporter_NodeElement_Texture(mNodeElement_Cur);
+    CAMFImporter_NodeElement *ne = new CAMFImporter_NodeElement_Texture(mNodeElement_Cur);
 
 	CAMFImporter_NodeElement_Texture& als = *((CAMFImporter_NodeElement_Texture*)ne);// alias for convenience
 
 	// Check for child nodes
-	if(!mReader->isEmptyElement()) XML_ReadNode_GetVal_AsString(enc64_data);
+    if (!mReader->isEmptyElement()) {
+        XML_ReadNode_GetVal_AsString(enc64_data);
+    }
 
 	// check that all components was defined
-	if(id.empty()) throw DeadlyImportError("ID for texture must be defined.");
-	if(width < 1) Throw_IncorrectAttrValue("width");
-	if(height < 1) Throw_IncorrectAttrValue("height");
-	if(depth < 1) Throw_IncorrectAttrValue("depth");
-	if(type != "grayscale") Throw_IncorrectAttrValue("type");
-	if(enc64_data.empty()) throw DeadlyImportError("Texture data not defined.");
+    if (id.empty()) {
+        throw DeadlyImportError("ID for texture must be defined.");
+    }
+    if (width < 1) {
+        Throw_IncorrectAttrValue("width");
+    }
+    if (height < 1) {
+        Throw_IncorrectAttrValue("height");
+    }
+    if (depth < 1) {
+        Throw_IncorrectAttrValue("depth");
+    }
+    if (type != "grayscale") {
+        Throw_IncorrectAttrValue("type");
+    }
+    if (enc64_data.empty()) {
+        throw DeadlyImportError("Texture data not defined.");
+    }
 	// copy data
 	als.ID = id;
 	als.Width = width;
@@ -222,8 +239,11 @@ CAMFImporter_NodeElement* ne;
 	als.Depth = depth;
 	als.Tiled = tiled;
 	ParseHelper_Decode_Base64(enc64_data, als.Data);
-	// check data size
-	if((width * height * depth) != als.Data.size()) throw DeadlyImportError("Texture has incorrect data size.");
+
+    // check data size
+    if ((width * height * depth) != als.Data.size()) {
+        throw DeadlyImportError("Texture has incorrect data size.");
+    }
 
 	mNodeElement_Cur->Child.push_back(ne);// Add element to child list of current element
 	mNodeElement_List.push_back(ne);// and to node element list because its a new object in graph.
@@ -243,10 +263,8 @@ CAMFImporter_NodeElement* ne;
 //   <utex1>, <utex2>, <utex3>, <vtex1>, <vtex2>, <vtex3>. Old name: <u1>, <u2>, <u3>, <v1>, <v2>, <v3>.
 //   Multi elements - No.
 //   Texture coordinates for every vertex of triangle.
-void AMFImporter::ParseNode_TexMap(const bool pUseOldName)
-{
-std::string rtexid, gtexid, btexid, atexid;
-CAMFImporter_NodeElement* ne;
+void AMFImporter::ParseNode_TexMap(const bool pUseOldName) {
+    std::string rtexid, gtexid, btexid, atexid;
 
 	// Read attributes for node <color>.
 	MACRO_ATTRREAD_LOOPBEG;
@@ -257,7 +275,7 @@ CAMFImporter_NodeElement* ne;
 	MACRO_ATTRREAD_LOOPEND;
 
 	// create new texture coordinates object.
-	ne = new CAMFImporter_NodeElement_TexMap(mNodeElement_Cur);
+    CAMFImporter_NodeElement *ne = new CAMFImporter_NodeElement_TexMap(mNodeElement_Cur);
 
 	CAMFImporter_NodeElement_TexMap& als = *((CAMFImporter_NodeElement_TexMap*)ne);// alias for convenience
 	// check data

code/AMFImporter_Node.hpp

@@ -62,7 +62,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 /// \class CAMFImporter_NodeElement
 /// Base class for elements of nodes.
 class CAMFImporter_NodeElement {
-
 public:
 	/// Define what data type contain node element.
 	enum EType {
@@ -96,15 +95,11 @@ public:                                               /// Destructor, virtual..
         // empty
     }
 
-private:
-	/// Disabled copy constructor.
-	CAMFImporter_NodeElement(const CAMFImporter_NodeElement& pNodeElement);
-
-	/// Disabled assign operator.
-	CAMFImporter_NodeElement& operator=(const CAMFImporter_NodeElement& pNodeElement);
-
-	/// Disabled default constructor.
-	CAMFImporter_NodeElement();
+	/// Disabled copy constructor and co.
+	CAMFImporter_NodeElement(const CAMFImporter_NodeElement& pNodeElement) = delete;
+    CAMFImporter_NodeElement(CAMFImporter_NodeElement&&) = delete;
+    CAMFImporter_NodeElement& operator=(const CAMFImporter_NodeElement& pNodeElement) = delete;
+	CAMFImporter_NodeElement() = delete;
 
 protected:
 	/// In constructor inheritor must set element type.
@@ -121,9 +116,7 @@ protected:
 
 /// \struct CAMFImporter_NodeElement_Constellation
 /// A collection of objects or constellations with specific relative locations.
-struct CAMFImporter_NodeElement_Constellation : public CAMFImporter_NodeElement
-{
-	/// \fn CAMFImporter_NodeElement_Constellation(CAMFImporter_NodeElement* pParent)
+struct CAMFImporter_NodeElement_Constellation : public CAMFImporter_NodeElement {
 	/// Constructor.
 	/// \param [in] pParent - pointer to parent node.
 	CAMFImporter_NodeElement_Constellation(CAMFImporter_NodeElement* pParent)
@@ -134,9 +127,7 @@ struct CAMFImporter_NodeElement_Constellation : public CAMFImporter_NodeElement
 
 /// \struct CAMFImporter_NodeElement_Instance
 /// Part of constellation.
-struct CAMFImporter_NodeElement_Instance : public CAMFImporter_NodeElement
-{
-	/****************** Variables ******************/
+struct CAMFImporter_NodeElement_Instance : public CAMFImporter_NodeElement {
 
 	std::string ObjectID;///< ID of object for instantiation.
 	/// \var Delta - The distance of translation in the x, y, or z direction, respectively, in the referenced object's coordinate system, to
@@ -147,237 +138,185 @@ struct CAMFImporter_NodeElement_Instance : public CAMFImporter_NodeElement
 	/// instance of the object in the current constellation. Rotations shall be executed in order of x first, then y, then z.
 	aiVector3D Rotation;
 
-	/****************** Functions ******************/
-
-	/// \fn CAMFImporter_NodeElement_Instance(CAMFImporter_NodeElement* pParent)
 	/// Constructor.
 	/// \param [in] pParent - pointer to parent node.
 	CAMFImporter_NodeElement_Instance(CAMFImporter_NodeElement* pParent)
 		: CAMFImporter_NodeElement(ENET_Instance, pParent)
 	{}
-
-};// struct CAMFImporter_NodeElement_Instance
+};
 
 /// \struct CAMFImporter_NodeElement_Metadata
 /// Structure that define metadata node.
-struct CAMFImporter_NodeElement_Metadata : public CAMFImporter_NodeElement
-{
-	/****************** Variables ******************/
+struct CAMFImporter_NodeElement_Metadata : public CAMFImporter_NodeElement {
 
-	std::string Type;///< Type of "Value".
+	std::string Type;///< Type of "Value". 
 	std::string Value;///< Value.
 
-	/****************** Functions ******************/
-
-	/// \fn CAMFImporter_NodeElement_Metadata(CAMFImporter_NodeElement* pParent)
 	/// Constructor.
 	/// \param [in] pParent - pointer to parent node.
 	CAMFImporter_NodeElement_Metadata(CAMFImporter_NodeElement* pParent)
 		: CAMFImporter_NodeElement(ENET_Metadata, pParent)
 	{}
-
-};// struct CAMFImporter_NodeElement_Metadata
+};
 
 /// \struct CAMFImporter_NodeElement_Root
 /// Structure that define root node.
-struct CAMFImporter_NodeElement_Root : public CAMFImporter_NodeElement
-{
-	/****************** Variables ******************/
+struct CAMFImporter_NodeElement_Root : public CAMFImporter_NodeElement {
 
 	std::string Unit;///< The units to be used. May be "inch", "millimeter", "meter", "feet", or "micron".
 	std::string Version;///< Version of format.
 
-	/****************** Functions ******************/
-
-	/// \fn CAMFImporter_NodeElement_Root(CAMFImporter_NodeElement* pParent)
 	/// Constructor.
 	/// \param [in] pParent - pointer to parent node.
 	CAMFImporter_NodeElement_Root(CAMFImporter_NodeElement* pParent)
 		: CAMFImporter_NodeElement(ENET_Root, pParent)
 	{}
-
-};// struct CAMFImporter_NodeElement_Root
+};
 
 /// \struct CAMFImporter_NodeElement_Color
 /// Structure that define object node.
-struct CAMFImporter_NodeElement_Color : public CAMFImporter_NodeElement
-{
-	/****************** Variables ******************/
-
-	bool Composed;///< Type of color stored: if true then look for formula in \ref Color_Composed[4], else - in \ref Color.
-	std::string Color_Composed[4];///< By components formulas of composed color. [0..3] => RGBA.
-	aiColor4D Color;///< Constant color.
-	std::string Profile;///< The ICC color space used to interpret the three color channels <r>, <g> and <b>..
-
-	/****************** Functions ******************/
-
-	/// \fn CAMFImporter_NodeElement_Color(CAMFImporter_NodeElement* pParent)
-	/// Constructor.
-	/// \param [in] pParent - pointer to parent node.
+struct CAMFImporter_NodeElement_Color : public CAMFImporter_NodeElement {
+	bool Composed;                  ///< Type of color stored: if true then look for formula in \ref Color_Composed[4], else - in \ref Color.
+	std::string Color_Composed[4];  ///< By components formulas of composed color. [0..3] - RGBA.
+	aiColor4D Color;                ///< Constant color.
+	std::string Profile;            ///< The ICC color space used to interpret the three color channels r, g and b..
+
+	/// @brief  Constructor.
+	/// @param [in] pParent - pointer to parent node.
 	CAMFImporter_NodeElement_Color(CAMFImporter_NodeElement* pParent)
-		: CAMFImporter_NodeElement(ENET_Color, pParent)
-	{}
-
-};// struct CAMFImporter_NodeElement_Color
+	: CAMFImporter_NodeElement(ENET_Color, pParent)
+    , Composed( false )
+    , Color()
+    , Profile() {
+        // empty
+    }
+};
 
 /// \struct CAMFImporter_NodeElement_Material
 /// Structure that define material node.
-struct CAMFImporter_NodeElement_Material : public CAMFImporter_NodeElement
-{
-	/// \fn CAMFImporter_NodeElement_Material(CAMFImporter_NodeElement* pParent)
+struct CAMFImporter_NodeElement_Material : public CAMFImporter_NodeElement {
+	
 	/// Constructor.
 	/// \param [in] pParent - pointer to parent node.
 	CAMFImporter_NodeElement_Material(CAMFImporter_NodeElement* pParent)
 		: CAMFImporter_NodeElement(ENET_Material, pParent)
 	{}
 
-};// struct CAMFImporter_NodeElement_Material
+};
 
 /// \struct CAMFImporter_NodeElement_Object
 /// Structure that define object node.
-struct CAMFImporter_NodeElement_Object : public CAMFImporter_NodeElement
-{
-	/// \fn CAMFImporter_NodeElement_Object(CAMFImporter_NodeElement* pParent)
-	/// Constructor.
+struct CAMFImporter_NodeElement_Object : public CAMFImporter_NodeElement {
+
+    /// Constructor.
 	/// \param [in] pParent - pointer to parent node.
 	CAMFImporter_NodeElement_Object(CAMFImporter_NodeElement* pParent)
 		: CAMFImporter_NodeElement(ENET_Object, pParent)
 	{}
-
-};// struct CAMFImporter_NodeElement_Object
+};
 
 /// \struct CAMFImporter_NodeElement_Mesh
 /// Structure that define mesh node.
-struct CAMFImporter_NodeElement_Mesh : public CAMFImporter_NodeElement
-{
-	/// \fn CAMFImporter_NodeElement_Mesh(CAMFImporter_NodeElement* pParent)
+struct CAMFImporter_NodeElement_Mesh : public CAMFImporter_NodeElement {
 	/// Constructor.
 	/// \param [in] pParent - pointer to parent node.
 	CAMFImporter_NodeElement_Mesh(CAMFImporter_NodeElement* pParent)
 		: CAMFImporter_NodeElement(ENET_Mesh, pParent)
 	{}
-
-};// struct CAMFImporter_NodeElement_Mesh
+};
 
 /// \struct CAMFImporter_NodeElement_Vertex
 /// Structure that define vertex node.
-struct CAMFImporter_NodeElement_Vertex : public CAMFImporter_NodeElement
-{
-	/// \fn CAMFImporter_NodeElement_Vertex(CAMFImporter_NodeElement* pParent)
+struct CAMFImporter_NodeElement_Vertex : public CAMFImporter_NodeElement {
 	/// Constructor.
 	/// \param [in] pParent - pointer to parent node.
 	CAMFImporter_NodeElement_Vertex(CAMFImporter_NodeElement* pParent)
 		: CAMFImporter_NodeElement(ENET_Vertex, pParent)
 	{}
-
-};// struct CAMFImporter_NodeElement_Vertex
+};
 
 /// \struct CAMFImporter_NodeElement_Edge
 /// Structure that define edge node.
-struct CAMFImporter_NodeElement_Edge : public CAMFImporter_NodeElement
-{
-	/// \fn CAMFImporter_NodeElement_Edge(CAMFImporter_NodeElement* pParent)
+struct CAMFImporter_NodeElement_Edge : public CAMFImporter_NodeElement {
 	/// Constructor.
 	/// \param [in] pParent - pointer to parent node.
 	CAMFImporter_NodeElement_Edge(CAMFImporter_NodeElement* pParent)
 		: CAMFImporter_NodeElement(ENET_Edge, pParent)
 	{}
 
-};// struct CAMFImporter_NodeElement_Vertex
+};
 
 /// \struct CAMFImporter_NodeElement_Vertices
 /// Structure that define vertices node.
-struct CAMFImporter_NodeElement_Vertices : public CAMFImporter_NodeElement
-{
-	/// \fn CAMFImporter_NodeElement_Vertices(CAMFImporter_NodeElement* pParent)
+struct CAMFImporter_NodeElement_Vertices : public CAMFImporter_NodeElement {
 	/// Constructor.
 	/// \param [in] pParent - pointer to parent node.
 	CAMFImporter_NodeElement_Vertices(CAMFImporter_NodeElement* pParent)
 		: CAMFImporter_NodeElement(ENET_Vertices, pParent)
 	{}
-
-};// struct CAMFImporter_NodeElement_Vertices
+};
 
 /// \struct CAMFImporter_NodeElement_Volume
 /// Structure that define volume node.
-struct CAMFImporter_NodeElement_Volume : public CAMFImporter_NodeElement
-{
-	/****************** Variables ******************/
-
+struct CAMFImporter_NodeElement_Volume : public CAMFImporter_NodeElement {
 	std::string MaterialID;///< Which material to use.
 	std::string Type;///< What this volume describes can be “region” or “support”. If none specified, “object” is assumed.
 
-	/****************** Functions ******************/
-
-	/// \fn CAMFImporter_NodeElement_Volume(CAMFImporter_NodeElement* pParent)
 	/// Constructor.
 	/// \param [in] pParent - pointer to parent node.
 	CAMFImporter_NodeElement_Volume(CAMFImporter_NodeElement* pParent)
 		: CAMFImporter_NodeElement(ENET_Volume, pParent)
 	{}
-
-};// struct CAMFImporter_NodeElement_Volume
+};
 
 /// \struct CAMFImporter_NodeElement_Coordinates
 /// Structure that define coordinates node.
 struct CAMFImporter_NodeElement_Coordinates : public CAMFImporter_NodeElement
 {
-	/****************** Variables ******************/
-
 	aiVector3D Coordinate;///< Coordinate.
 
-	/****************** Functions ******************/
-
-	/// \fn CAMFImporter_NodeElement_Coordinates(CAMFImporter_NodeElement* pParent)
 	/// Constructor.
 	/// \param [in] pParent - pointer to parent node.
 	CAMFImporter_NodeElement_Coordinates(CAMFImporter_NodeElement* pParent)
 		: CAMFImporter_NodeElement(ENET_Coordinates, pParent)
 	{}
 
-};// struct CAMFImporter_NodeElement_Coordinates
+};
 
 /// \struct CAMFImporter_NodeElement_TexMap
 /// Structure that define texture coordinates node.
-struct CAMFImporter_NodeElement_TexMap : public CAMFImporter_NodeElement
-{
-	/****************** Variables ******************/
-
+struct CAMFImporter_NodeElement_TexMap : public CAMFImporter_NodeElement {
 	aiVector3D TextureCoordinate[3];///< Texture coordinates.
 	std::string TextureID_R;///< Texture ID for red color component.
 	std::string TextureID_G;///< Texture ID for green color component.
 	std::string TextureID_B;///< Texture ID for blue color component.
 	std::string TextureID_A;///< Texture ID for alpha color component.
 
-	/****************** Functions ******************/
-
-	/// \fn CAMFImporter_NodeElement_TexMap(CAMFImporter_NodeElement* pParent)
 	/// Constructor.
 	/// \param [in] pParent - pointer to parent node.
 	CAMFImporter_NodeElement_TexMap(CAMFImporter_NodeElement* pParent)
-		: CAMFImporter_NodeElement(ENET_TexMap, pParent)
-	{}
-
-};// struct CAMFImporter_NodeElement_TexMap
+	: CAMFImporter_NodeElement(ENET_TexMap, pParent)
+    , TextureCoordinate{}
+    , TextureID_R()
+    , TextureID_G()
+    , TextureID_B()
+    , TextureID_A()	{
+        // empty
+    }
+};
 
 /// \struct CAMFImporter_NodeElement_Triangle
 /// Structure that define triangle node.
-struct CAMFImporter_NodeElement_Triangle : public CAMFImporter_NodeElement
-{
-	/****************** Variables ******************/
-
+struct CAMFImporter_NodeElement_Triangle : public CAMFImporter_NodeElement {
 	size_t V[3];///< Triangle vertices.
 
-	/****************** Functions ******************/
-
-	/// \fn CAMFImporter_NodeElement_Triangle(CAMFImporter_NodeElement* pParent)
 	/// Constructor.
 	/// \param [in] pParent - pointer to parent node.
 	CAMFImporter_NodeElement_Triangle(CAMFImporter_NodeElement* pParent)
-		: CAMFImporter_NodeElement(ENET_Triangle, pParent)
-	{}
-
-};// struct CAMFImporter_NodeElement_Triangle
+	: CAMFImporter_NodeElement(ENET_Triangle, pParent) {
+        // empty
+    }
+};
 
 /// Structure that define texture node.
 struct CAMFImporter_NodeElement_Texture : public CAMFImporter_NodeElement {
@@ -396,6 +335,6 @@ struct CAMFImporter_NodeElement_Texture : public CAMFImporter_NodeElement {
     , Tiled( false ){
         // empty
     }
-};// struct CAMFImporter_NodeElement_Texture
+};
 
 #endif // INCLUDED_AI_AMF_IMPORTER_NODE_H

code/ASEParser.h

@@ -71,21 +71,20 @@ struct Material : public D3DS::Material
     //! Default constructor has been deleted
     Material() = delete;
 
-
     //! Constructor with explicit name
     explicit Material(const std::string &name)
     : D3DS::Material(name)
     , pcInstance(NULL)
-    , bNeed (false)
-    {}
-
+    , bNeed (false) {
+        // empty
+    }
 
     Material(const Material &other)            = default;
     Material &operator=(const Material &other) = default;
 
 
     //! Move constructor. This is explicitly written because MSVC doesn't support defaulting it
-    Material(Material &&other)
+    Material(Material &&other) AI_NO_EXCEPT
     : D3DS::Material(std::move(other))
     , avSubMaterials(std::move(other.avSubMaterials))
     , pcInstance(std::move(other.pcInstance))
@@ -95,7 +94,7 @@ struct Material : public D3DS::Material
     }
 
 
-    Material &operator=(Material &&other) {
+    Material &operator=(Material &&other) AI_NO_EXCEPT {
         if (this == &other) {
             return *this;
         }
@@ -127,19 +126,12 @@ struct Material : public D3DS::Material
 
 // ---------------------------------------------------------------------------
 /** Helper structure to represent an ASE file face */
-struct Face : public FaceWithSmoothingGroup
-{
+struct Face : public FaceWithSmoothingGroup {
     //! Default constructor. Initializes everything with 0
-    Face()
-    {
-        mColorIndices[0] = mColorIndices[1] = mColorIndices[2] = 0;
-        for (unsigned int i = 0; i < AI_MAX_NUMBER_OF_TEXTURECOORDS;++i)
-        {
-            amUVIndices[i][0] = amUVIndices[i][1] = amUVIndices[i][2] = 0;
-        }
-
-        iMaterial = DEFAULT_MATINDEX;
-        iFace = 0;
+    Face() AI_NO_EXCEPT
+    : iMaterial(DEFAULT_MATINDEX)
+    , iFace(0) {
+        // empty
     }
 
     //! special value to indicate that no material index has
@@ -147,8 +139,6 @@ struct Face : public FaceWithSmoothingGroup
     //! will replace this value later.
     static const unsigned int DEFAULT_MATINDEX = 0xFFFFFFFF;
 
-
-
     //! Indices into each list of texture coordinates
     unsigned int amUVIndices[AI_MAX_NUMBER_OF_TEXTURECOORDS][3];
 
@@ -166,15 +156,15 @@ struct Face : public FaceWithSmoothingGroup
 
 // ---------------------------------------------------------------------------
 /** Helper structure to represent an ASE file bone */
-struct Bone
-{
+struct Bone {
     //! Constructor
     Bone() = delete;
 
     //! Construction from an existing name
     explicit Bone( const std::string& name)
-        :   mName   (name)
-    {}
+    : mName(name) {
+        // empty
+    }
 
     //! Name of the bone
     std::string mName;
@@ -182,29 +172,22 @@ struct Bone
 
 // ---------------------------------------------------------------------------
 /** Helper structure to represent an ASE file bone vertex */
-struct BoneVertex
-{
+struct BoneVertex {
     //! Bone and corresponding vertex weight.
     //! -1 for unrequired bones ....
     std::vector<std::pair<int,float> > mBoneWeights;
-
-    //! Position of the bone vertex.
-    //! MUST be identical to the vertex position
-    //aiVector3D mPosition;
 };
 
 // ---------------------------------------------------------------------------
 /** Helper structure to represent an ASE file animation */
-struct Animation
-{
-    enum Type
-    {
+struct Animation {
+    enum Type {
         TRACK   = 0x0,
         BEZIER  = 0x1,
         TCB     = 0x2
     } mRotationType, mScalingType, mPositionType;
 
-    Animation()
+    Animation() AI_NO_EXCEPT
         :   mRotationType   (TRACK)
         ,   mScalingType    (TRACK)
         ,   mPositionType   (TRACK)
@@ -218,19 +201,16 @@ struct Animation
 
     //! List of track scaling keyframes
     std::vector< aiVectorKey > akeyScaling;
-
 };
 
 // ---------------------------------------------------------------------------
 /** Helper structure to represent the inheritance information of an ASE node */
-struct InheritanceInfo
-{
+struct InheritanceInfo {
     //! Default constructor
-    InheritanceInfo()
-    {
-        // set the inheritance flag for all axes by default to true
-        for (unsigned int i = 0; i < 3;++i)
+    InheritanceInfo() AI_NO_EXCEPT {
+        for ( size_t i=0; i<3; ++i ) {
             abInheritPosition[i] = abInheritRotation[i] = abInheritScaling[i] = true;
+        }
     }
 
     //! Inherit the parent's position?, axis order is x,y,z
@@ -245,17 +225,19 @@ struct InheritanceInfo
 
 // ---------------------------------------------------------------------------
 /** Represents an ASE file node. Base class for mesh, light and cameras */
-struct BaseNode
-{
-    enum Type {Light, Camera, Mesh, Dummy} mType;
-
+struct BaseNode {
+    enum Type {
+        Light, 
+        Camera, 
+        Mesh, 
+        Dummy
+    } mType;
 
     //! Construction from an existing name
     BaseNode(Type _mType, const std::string &name)
     : mType         (_mType)
     , mName         (name)
-    , mProcessed    (false)
-    {
+    , mProcessed    (false) {
         // Set mTargetPosition to qnan
         const ai_real qnan = get_qnan();
         mTargetPosition.x = qnan;
@@ -291,24 +273,23 @@ struct BaseNode
 
 // ---------------------------------------------------------------------------
 /** Helper structure to represent an ASE file mesh */
-struct Mesh : public MeshWithSmoothingGroups<ASE::Face>, public BaseNode
-{
+struct Mesh : public MeshWithSmoothingGroups<ASE::Face>, public BaseNode {
     //! Default constructor has been deleted
     Mesh() = delete;
 
-
     //! Construction from an existing name
     explicit Mesh(const std::string &name)
-    : BaseNode  (BaseNode::Mesh, name)
+    : BaseNode( BaseNode::Mesh, name )
+    , mVertexColors()
+    , mBoneVertices()
+    , mBones()
     , iMaterialIndex(Face::DEFAULT_MATINDEX)
-    , bSkip     (false)
-    {
-        // use 2 texture vertex components by default
-        for (unsigned int c = 0; c < AI_MAX_NUMBER_OF_TEXTURECOORDS;++c)
+    , bSkip     (false) {
+        for (unsigned int c = 0; c < AI_MAX_NUMBER_OF_TEXTURECOORDS;++c) {
             this->mNumUVComponents[c] = 2;
+        }
     }
 
-
     //! List of all texture coordinate sets
     std::vector<aiVector3D> amTexCoords[AI_MAX_NUMBER_OF_TEXTURECOORDS];
 
@@ -396,12 +377,11 @@ struct Camera : public BaseNode
 
 // ---------------------------------------------------------------------------
 /** Helper structure to represent an ASE helper object (dummy) */
-struct Dummy : public BaseNode
-{
+struct Dummy : public BaseNode {
     //! Constructor
-    Dummy()
-        : BaseNode  (BaseNode::Dummy, "DUMMY")
-    {
+    Dummy() AI_NO_EXCEPT
+    : BaseNode  (BaseNode::Dummy, "DUMMY") {
+        // empty
     }
 };
 
@@ -416,12 +396,11 @@ struct Dummy : public BaseNode
 // -------------------------------------------------------------------------------
 /** \brief Class to parse ASE files
  */
-class Parser
-{
-
+class Parser {
 private:
-
-    Parser() {}
+    Parser() AI_NO_EXCEPT {
+        // empty
+    }
 
 public:
 

code/AssbinExporter.cpp

@@ -62,148 +62,154 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include <time.h>
 
-using namespace Assimp;
-
-namespace Assimp    {
+namespace Assimp {
 
 template <typename T>
-size_t Write(IOStream * stream, const T& v)
-{
+size_t Write(IOStream * stream, const T& v) {
     return stream->Write( &v, sizeof(T), 1 );
 }
 
-
 // -----------------------------------------------------------------------------------
 // Serialize an aiString
 template <>
-inline size_t Write<aiString>(IOStream * stream, const aiString& s)
-{
+inline
+size_t Write<aiString>(IOStream * stream, const aiString& s) {
     const size_t s2 = (uint32_t)s.length;
     stream->Write(&s,4,1);
     stream->Write(s.data,s2,1);
+
     return s2+4;
 }
 
 // -----------------------------------------------------------------------------------
 // Serialize an unsigned int as uint32_t
 template <>
-inline size_t Write<unsigned int>(IOStream * stream, const unsigned int& w)
-{
+inline
+size_t Write<unsigned int>(IOStream * stream, const unsigned int& w) {
     const uint32_t t = (uint32_t)w;
     if (w > t) {
         // this shouldn't happen, integers in Assimp data structures never exceed 2^32
-        throw new DeadlyExportError("loss of data due to 64 -> 32 bit integer conversion");
+        throw DeadlyExportError("loss of data due to 64 -> 32 bit integer conversion");
     }
 
     stream->Write(&t,4,1);
+
     return 4;
 }
 
 // -----------------------------------------------------------------------------------
 // Serialize an unsigned int as uint16_t
 template <>
-inline size_t Write<uint16_t>(IOStream * stream, const uint16_t& w)
-{
+inline
+size_t Write<uint16_t>(IOStream * stream, const uint16_t& w) {
     static_assert(sizeof(uint16_t)==2, "sizeof(uint16_t)==2");
     stream->Write(&w,2,1);
+
     return 2;
 }
 
 // -----------------------------------------------------------------------------------
 // Serialize a float
 template <>
-inline size_t Write<float>(IOStream * stream, const float& f)
-{
+inline
+size_t Write<float>(IOStream * stream, const float& f) {
     static_assert(sizeof(float)==4, "sizeof(float)==4");
     stream->Write(&f,4,1);
+
     return 4;
 }
 
 // -----------------------------------------------------------------------------------
 // Serialize a double
 template <>
-inline size_t Write<double>(IOStream * stream, const double& f)
-{
+inline
+size_t Write<double>(IOStream * stream, const double& f) {
     static_assert(sizeof(double)==8, "sizeof(double)==8");
     stream->Write(&f,8,1);
+
     return 8;
 }
 
 // -----------------------------------------------------------------------------------
 // Serialize a vec3
 template <>
-inline size_t Write<aiVector3D>(IOStream * stream, const aiVector3D& v)
-{
+inline
+size_t Write<aiVector3D>(IOStream * stream, const aiVector3D& v) {
     size_t t = Write<float>(stream,v.x);
     t += Write<float>(stream,v.y);
     t += Write<float>(stream,v.z);
+
     return t;
 }
 
 // -----------------------------------------------------------------------------------
 // Serialize a color value
 template <>
-inline size_t Write<aiColor3D>(IOStream * stream, const aiColor3D& v)
-{
+inline
+size_t Write<aiColor3D>(IOStream * stream, const aiColor3D& v) {
     size_t t = Write<float>(stream,v.r);
     t += Write<float>(stream,v.g);
     t += Write<float>(stream,v.b);
+
     return t;
 }
 
 // -----------------------------------------------------------------------------------
 // Serialize a color value
 template <>
-inline size_t Write<aiColor4D>(IOStream * stream, const aiColor4D& v)
-{
+inline
+size_t Write<aiColor4D>(IOStream * stream, const aiColor4D& v) {
     size_t t = Write<float>(stream,v.r);
     t += Write<float>(stream,v.g);
     t += Write<float>(stream,v.b);
     t += Write<float>(stream,v.a);
+
     return t;
 }
 
 // -----------------------------------------------------------------------------------
 // Serialize a quaternion
 template <>
-inline size_t Write<aiQuaternion>(IOStream * stream, const aiQuaternion& v)
-{
+inline
+size_t Write<aiQuaternion>(IOStream * stream, const aiQuaternion& v) {
     size_t t = Write<float>(stream,v.w);
     t += Write<float>(stream,v.x);
     t += Write<float>(stream,v.y);
     t += Write<float>(stream,v.z);
     ai_assert(t == 16);
+
     return 16;
 }
 
-
 // -----------------------------------------------------------------------------------
 // Serialize a vertex weight
 template <>
-inline size_t Write<aiVertexWeight>(IOStream * stream, const aiVertexWeight& v)
-{
+inline
+size_t Write<aiVertexWeight>(IOStream * stream, const aiVertexWeight& v) {
     size_t t = Write<unsigned int>(stream,v.mVertexId);
+
     return t+Write<float>(stream,v.mWeight);
 }
 
 // -----------------------------------------------------------------------------------
 // Serialize a mat4x4
 template <>
-inline size_t Write<aiMatrix4x4>(IOStream * stream, const aiMatrix4x4& m)
-{
+inline
+size_t Write<aiMatrix4x4>(IOStream * stream, const aiMatrix4x4& m) {
     for (unsigned int i = 0; i < 4;++i) {
         for (unsigned int i2 = 0; i2 < 4;++i2) {
             Write<float>(stream,m[i][i2]);
         }
     }
+
     return 64;
 }
 
 // -----------------------------------------------------------------------------------
 // Serialize an aiVectorKey
 template <>
-inline size_t Write<aiVectorKey>(IOStream * stream, const aiVectorKey& v)
-{
+inline
+size_t Write<aiVectorKey>(IOStream * stream, const aiVectorKey& v) {
     const size_t t = Write<double>(stream,v.mTime);
     return t + Write<aiVector3D>(stream,v.mValue);
 }
@@ -211,16 +217,16 @@ inline size_t Write<aiVectorKey>(IOStream * stream, const aiVectorKey& v)
 // -----------------------------------------------------------------------------------
 // Serialize an aiQuatKey
 template <>
-inline size_t Write<aiQuatKey>(IOStream * stream, const aiQuatKey& v)
-{
+inline
+size_t Write<aiQuatKey>(IOStream * stream, const aiQuatKey& v) {
     const size_t t = Write<double>(stream,v.mTime);
     return t + Write<aiQuaternion>(stream,v.mValue);
 }
 
 template <typename T>
-inline size_t WriteBounds(IOStream * stream, const T* in, unsigned int size)
-{
-    T minc,maxc;
+inline
+size_t WriteBounds(IOStream * stream, const T* in, unsigned int size) {
+    T minc, maxc;
     ArrayBounds(in,size,minc,maxc);
 
     const size_t t = Write<T>(stream,minc);
@@ -230,590 +236,601 @@ inline size_t WriteBounds(IOStream * stream, const T* in, unsigned int size)
 // We use this to write out non-byte arrays so that we write using the specializations.
 // This way we avoid writing out extra bytes that potentially come from struct alignment.
 template <typename T>
-inline size_t WriteArray(IOStream * stream, const T* in, unsigned int size)
-{
+inline
+size_t WriteArray(IOStream * stream, const T* in, unsigned int size) {
     size_t n = 0;
     for (unsigned int i=0; i<size; i++) n += Write<T>(stream,in[i]);
+
     return n;
 }
 
-    // ----------------------------------------------------------------------------------
-    /** @class  AssbinChunkWriter
-     *  @brief  Chunk writer mechanism for the .assbin file structure
-     *
-     *  This is a standard in-memory IOStream (most of the code is based on BlobIOStream),
-     *  the difference being that this takes another IOStream as a "container" in the
-     *  constructor, and when it is destroyed, it appends the magic number, the chunk size,
-     *  and the chunk contents to the container stream. This allows relatively easy chunk
-     *  chunk construction, even recursively.
-     */
-    class AssbinChunkWriter : public IOStream
-    {
-    private:
-
-        uint8_t* buffer;
-        uint32_t magic;
-        IOStream * container;
-        size_t cur_size, cursor, initial;
+// ----------------------------------------------------------------------------------
+/** @class  AssbinChunkWriter
+ *  @brief  Chunk writer mechanism for the .assbin file structure
+ *
+ *  This is a standard in-memory IOStream (most of the code is based on BlobIOStream),
+ *  the difference being that this takes another IOStream as a "container" in the
+ *  constructor, and when it is destroyed, it appends the magic number, the chunk size,
+ *  and the chunk contents to the container stream. This allows relatively easy chunk
+ *  chunk construction, even recursively.
+ */
+class AssbinChunkWriter : public IOStream
+{
+private:
 
-    private:
-        // -------------------------------------------------------------------
-        void Grow(size_t need = 0)
-        {
-            size_t new_size = std::max(initial, std::max( need, cur_size+(cur_size>>1) ));
+    uint8_t* buffer;
+    uint32_t magic;
+    IOStream * container;
+    size_t cur_size, cursor, initial;
 
-            const uint8_t* const old = buffer;
-            buffer = new uint8_t[new_size];
+private:
+    // -------------------------------------------------------------------
+    void Grow(size_t need = 0)
+    {
+        size_t new_size = std::max(initial, std::max( need, cur_size+(cur_size>>1) ));
 
-            if (old) {
-                memcpy(buffer,old,cur_size);
-                delete[] old;
-            }
+        const uint8_t* const old = buffer;
+        buffer = new uint8_t[new_size];
 
-            cur_size = new_size;
+        if (old) {
+            memcpy(buffer,old,cur_size);
+            delete[] old;
         }
 
-    public:
+        cur_size = new_size;
+    }
 
-        AssbinChunkWriter( IOStream * container, uint32_t magic, size_t initial = 4096)
-            : buffer(NULL), magic(magic), container(container), cur_size(0), cursor(0), initial(initial)
-        {
-        }
+public:
 
-        virtual ~AssbinChunkWriter()
-        {
-            if (container) {
-                container->Write( &magic, sizeof(uint32_t), 1 );
-                container->Write( &cursor, sizeof(uint32_t), 1 );
-                container->Write( buffer, 1, cursor );
-            }
-            if (buffer) delete[] buffer;
+    AssbinChunkWriter( IOStream * container, uint32_t magic, size_t initial = 4096)
+        : buffer(NULL), magic(magic), container(container), cur_size(0), cursor(0), initial(initial)
+    {
+    }
+
+    virtual ~AssbinChunkWriter()
+    {
+        if (container) {
+            container->Write( &magic, sizeof(uint32_t), 1 );
+            container->Write( &cursor, sizeof(uint32_t), 1 );
+            container->Write( buffer, 1, cursor );
         }
+        if (buffer) delete[] buffer;
+    }
+
+    void * GetBufferPointer() { return buffer; }
 
-        void * GetBufferPointer() { return buffer; }
+    // -------------------------------------------------------------------
+    virtual size_t Read(void* /*pvBuffer*/, size_t /*pSize*/, size_t /*pCount*/) {
+        return 0;
+    }
+    virtual aiReturn Seek(size_t /*pOffset*/, aiOrigin /*pOrigin*/) {
+        return aiReturn_FAILURE;
+    }
+    virtual size_t Tell() const {
+        return cursor;
+    }
+    virtual void Flush() {
+        // not implemented
+    }
 
-        // -------------------------------------------------------------------
-        virtual size_t Read(void* /*pvBuffer*/, size_t /*pSize*/, size_t /*pCount*/) { return 0; }
-        virtual aiReturn Seek(size_t /*pOffset*/, aiOrigin /*pOrigin*/) { return aiReturn_FAILURE; }
-        virtual size_t Tell() const { return cursor; }
-        virtual void Flush() { }
+    virtual size_t FileSize() const {
+        return cursor;
+    }
 
-        virtual size_t FileSize() const
-        {
-            return cursor;
+    // -------------------------------------------------------------------
+    virtual size_t Write(const void* pvBuffer, size_t pSize, size_t pCount) {
+        pSize *= pCount;
+        if (cursor + pSize > cur_size) {
+            Grow(cursor + pSize);
         }
 
-        // -------------------------------------------------------------------
-        virtual size_t Write(const void* pvBuffer, size_t pSize, size_t pCount)
-        {
-            pSize *= pCount;
-            if (cursor + pSize > cur_size) {
-                Grow(cursor + pSize);
-            }
+        memcpy(buffer+cursor, pvBuffer, pSize);
+        cursor += pSize;
 
-            memcpy(buffer+cursor, pvBuffer, pSize);
-            cursor += pSize;
+        return pCount;
+    }
 
-            return pCount;
-        }
+};
 
-    };
+// ----------------------------------------------------------------------------------
+/** @class  AssbinExport
+ *  @brief  Assbin exporter class
+ *
+ *  This class performs the .assbin exporting, and is responsible for the file layout.
+ */
+class AssbinExport
+{
+private:
+    bool shortened;
+    bool compressed;
 
-    // ----------------------------------------------------------------------------------
-    /** @class  AssbinExport
-     *  @brief  Assbin exporter class
-     *
-     *  This class performs the .assbin exporting, and is responsible for the file layout.
-     */
-    class AssbinExport
+protected:
+    // -----------------------------------------------------------------------------------
+    void WriteBinaryNode( IOStream * container, const aiNode* node)
     {
-    private:
-        bool shortened;
-        bool compressed;
+        AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AINODE );
 
-    protected:
+        unsigned int nb_metadata = (node->mMetaData != NULL ? node->mMetaData->mNumProperties : 0);
 
-        // -----------------------------------------------------------------------------------
-        void WriteBinaryNode( IOStream * container, const aiNode* node)
-        {
-            AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AINODE );
+        Write<aiString>(&chunk,node->mName);
+        Write<aiMatrix4x4>(&chunk,node->mTransformation);
+        Write<unsigned int>(&chunk,node->mNumChildren);
+        Write<unsigned int>(&chunk,node->mNumMeshes);
+        Write<unsigned int>(&chunk,nb_metadata);
 
-			unsigned int nb_metadata = (node->mMetaData != NULL ? node->mMetaData->mNumProperties : 0);
+        for (unsigned int i = 0; i < node->mNumMeshes;++i) {
+            Write<unsigned int>(&chunk,node->mMeshes[i]);
+        }
 
-            Write<aiString>(&chunk,node->mName);
-            Write<aiMatrix4x4>(&chunk,node->mTransformation);
-            Write<unsigned int>(&chunk,node->mNumChildren);
-            Write<unsigned int>(&chunk,node->mNumMeshes);
-			Write<unsigned int>(&chunk,nb_metadata);
+        for (unsigned int i = 0; i < node->mNumChildren;++i) {
+            WriteBinaryNode( &chunk, node->mChildren[i] );
+        }
 
-            for (unsigned int i = 0; i < node->mNumMeshes;++i) {
-                Write<unsigned int>(&chunk,node->mMeshes[i]);
-            }
+        for (unsigned int i = 0; i < nb_metadata; ++i) {
+            const aiString& key = node->mMetaData->mKeys[i];
+            aiMetadataType type = node->mMetaData->mValues[i].mType;
+            void* value = node->mMetaData->mValues[i].mData;
 
-            for (unsigned int i = 0; i < node->mNumChildren;++i) {
-                WriteBinaryNode( &chunk, node->mChildren[i] );
-            }
+            Write<aiString>(&chunk, key);
+            Write<uint16_t>(&chunk, type);
 
-			for (unsigned int i = 0; i < nb_metadata; ++i) {
-				const aiString& key = node->mMetaData->mKeys[i];
-				aiMetadataType type = node->mMetaData->mValues[i].mType;
-				void* value = node->mMetaData->mValues[i].mData;
-
-				Write<aiString>(&chunk, key);
-				Write<uint16_t>(&chunk, type);
-				
-				switch (type) {
-                    case AI_BOOL:
-                        Write<bool>(&chunk, *((bool*) value));
-                        break;
-                    case AI_INT32:
-                        Write<int32_t>(&chunk, *((int32_t*) value));
-                        break;
-                    case AI_UINT64:
-                        Write<uint64_t>(&chunk, *((uint64_t*) value));
-                        break;
-                    case AI_FLOAT:
-                        Write<float>(&chunk, *((float*) value));
-                        break;
-                    case AI_DOUBLE:
-                        Write<double>(&chunk, *((double*) value));
-                        break;
-                    case AI_AISTRING:
-                        Write<aiString>(&chunk, *((aiString*) value));
-                        break;
-                    case AI_AIVECTOR3D:
-                        Write<aiVector3D>(&chunk, *((aiVector3D*) value));
-                        break;
+            switch (type) {
+                case AI_BOOL:
+                    Write<bool>(&chunk, *((bool*) value));
+                    break;
+                case AI_INT32:
+                    Write<int32_t>(&chunk, *((int32_t*) value));
+                    break;
+                case AI_UINT64:
+                    Write<uint64_t>(&chunk, *((uint64_t*) value));
+                    break;
+                case AI_FLOAT:
+                    Write<float>(&chunk, *((float*) value));
+                    break;
+                case AI_DOUBLE:
+                    Write<double>(&chunk, *((double*) value));
+                    break;
+                case AI_AISTRING:
+                    Write<aiString>(&chunk, *((aiString*) value));
+                    break;
+                case AI_AIVECTOR3D:
+                    Write<aiVector3D>(&chunk, *((aiVector3D*) value));
+                    break;
 #ifdef SWIG
-                    case FORCE_32BIT:
+                case FORCE_32BIT:
 #endif // SWIG
-                    default:
-                        break;
-				}
-			}
+                default:
+                    break;
+            }
         }
+    }
 
-        // -----------------------------------------------------------------------------------
-        void WriteBinaryTexture(IOStream * container, const aiTexture* tex)
-        {
-            AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AITEXTURE );
+    // -----------------------------------------------------------------------------------
+    void WriteBinaryTexture(IOStream * container, const aiTexture* tex)
+    {
+        AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AITEXTURE );
 
-            Write<unsigned int>(&chunk,tex->mWidth);
-            Write<unsigned int>(&chunk,tex->mHeight);
-            chunk.Write( tex->achFormatHint, sizeof(char), 4 );
+        Write<unsigned int>(&chunk,tex->mWidth);
+        Write<unsigned int>(&chunk,tex->mHeight);
+        chunk.Write( tex->achFormatHint, sizeof(char), 4 );
 
-            if(!shortened) {
-                if (!tex->mHeight) {
-                    chunk.Write(tex->pcData,1,tex->mWidth);
-                }
-                else {
-                    chunk.Write(tex->pcData,1,tex->mWidth*tex->mHeight*4);
-                }
+        if(!shortened) {
+            if (!tex->mHeight) {
+                chunk.Write(tex->pcData,1,tex->mWidth);
+            }
+            else {
+                chunk.Write(tex->pcData,1,tex->mWidth*tex->mHeight*4);
             }
-
         }
 
-        // -----------------------------------------------------------------------------------
-        void WriteBinaryBone(IOStream * container, const aiBone* b)
-        {
-            AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AIBONE );
+    }
 
-            Write<aiString>(&chunk,b->mName);
-            Write<unsigned int>(&chunk,b->mNumWeights);
-            Write<aiMatrix4x4>(&chunk,b->mOffsetMatrix);
+    // -----------------------------------------------------------------------------------
+    void WriteBinaryBone(IOStream * container, const aiBone* b)
+    {
+        AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AIBONE );
+
+        Write<aiString>(&chunk,b->mName);
+        Write<unsigned int>(&chunk,b->mNumWeights);
+        Write<aiMatrix4x4>(&chunk,b->mOffsetMatrix);
+
+        // for the moment we write dumb min/max values for the bones, too.
+        // maybe I'll add a better, hash-like solution later
+        if (shortened) {
+            WriteBounds(&chunk,b->mWeights,b->mNumWeights);
+        } // else write as usual
+        else WriteArray<aiVertexWeight>(&chunk,b->mWeights,b->mNumWeights);
+    }
 
-            // for the moment we write dumb min/max values for the bones, too.
-            // maybe I'll add a better, hash-like solution later
-            if (shortened) {
-                WriteBounds(&chunk,b->mWeights,b->mNumWeights);
-            } // else write as usual
-            else WriteArray<aiVertexWeight>(&chunk,b->mWeights,b->mNumWeights);
+    // -----------------------------------------------------------------------------------
+    void WriteBinaryMesh(IOStream * container, const aiMesh* mesh)
+    {
+        AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AIMESH );
+
+        Write<unsigned int>(&chunk,mesh->mPrimitiveTypes);
+        Write<unsigned int>(&chunk,mesh->mNumVertices);
+        Write<unsigned int>(&chunk,mesh->mNumFaces);
+        Write<unsigned int>(&chunk,mesh->mNumBones);
+        Write<unsigned int>(&chunk,mesh->mMaterialIndex);
+
+        // first of all, write bits for all existent vertex components
+        unsigned int c = 0;
+        if (mesh->mVertices) {
+            c |= ASSBIN_MESH_HAS_POSITIONS;
         }
-
-        // -----------------------------------------------------------------------------------
-        void WriteBinaryMesh(IOStream * container, const aiMesh* mesh)
-        {
-            AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AIMESH );
-
-            Write<unsigned int>(&chunk,mesh->mPrimitiveTypes);
-            Write<unsigned int>(&chunk,mesh->mNumVertices);
-            Write<unsigned int>(&chunk,mesh->mNumFaces);
-            Write<unsigned int>(&chunk,mesh->mNumBones);
-            Write<unsigned int>(&chunk,mesh->mMaterialIndex);
-
-            // first of all, write bits for all existent vertex components
-            unsigned int c = 0;
-            if (mesh->mVertices) {
-                c |= ASSBIN_MESH_HAS_POSITIONS;
-            }
-            if (mesh->mNormals) {
-                c |= ASSBIN_MESH_HAS_NORMALS;
-            }
-            if (mesh->mTangents && mesh->mBitangents) {
-                c |= ASSBIN_MESH_HAS_TANGENTS_AND_BITANGENTS;
-            }
-            for (unsigned int n = 0; n < AI_MAX_NUMBER_OF_TEXTURECOORDS;++n) {
-                if (!mesh->mTextureCoords[n]) {
-                    break;
-                }
-                c |= ASSBIN_MESH_HAS_TEXCOORD(n);
-            }
-            for (unsigned int n = 0; n < AI_MAX_NUMBER_OF_COLOR_SETS;++n) {
-                if (!mesh->mColors[n]) {
-                    break;
-                }
-                c |= ASSBIN_MESH_HAS_COLOR(n);
-            }
-            Write<unsigned int>(&chunk,c);
-
-            aiVector3D minVec, maxVec;
-            if (mesh->mVertices) {
-                if (shortened) {
-                    WriteBounds(&chunk,mesh->mVertices,mesh->mNumVertices);
-                } // else write as usual
-                else WriteArray<aiVector3D>(&chunk,mesh->mVertices,mesh->mNumVertices);
-            }
-            if (mesh->mNormals) {
-                if (shortened) {
-                    WriteBounds(&chunk,mesh->mNormals,mesh->mNumVertices);
-                } // else write as usual
-                else WriteArray<aiVector3D>(&chunk,mesh->mNormals,mesh->mNumVertices);
+        if (mesh->mNormals) {
+            c |= ASSBIN_MESH_HAS_NORMALS;
+        }
+        if (mesh->mTangents && mesh->mBitangents) {
+            c |= ASSBIN_MESH_HAS_TANGENTS_AND_BITANGENTS;
+        }
+        for (unsigned int n = 0; n < AI_MAX_NUMBER_OF_TEXTURECOORDS;++n) {
+            if (!mesh->mTextureCoords[n]) {
+                break;
             }
-            if (mesh->mTangents && mesh->mBitangents) {
-                if (shortened) {
-                    WriteBounds(&chunk,mesh->mTangents,mesh->mNumVertices);
-                    WriteBounds(&chunk,mesh->mBitangents,mesh->mNumVertices);
-                } // else write as usual
-                else {
-                    WriteArray<aiVector3D>(&chunk,mesh->mTangents,mesh->mNumVertices);
-                    WriteArray<aiVector3D>(&chunk,mesh->mBitangents,mesh->mNumVertices);
-                }
+            c |= ASSBIN_MESH_HAS_TEXCOORD(n);
+        }
+        for (unsigned int n = 0; n < AI_MAX_NUMBER_OF_COLOR_SETS;++n) {
+            if (!mesh->mColors[n]) {
+                break;
             }
-            for (unsigned int n = 0; n < AI_MAX_NUMBER_OF_COLOR_SETS;++n) {
-                if (!mesh->mColors[n])
-                    break;
+            c |= ASSBIN_MESH_HAS_COLOR(n);
+        }
+        Write<unsigned int>(&chunk,c);
 
-                if (shortened) {
-                    WriteBounds(&chunk,mesh->mColors[n],mesh->mNumVertices);
-                } // else write as usual
-                else WriteArray<aiColor4D>(&chunk,mesh->mColors[n],mesh->mNumVertices);
+        aiVector3D minVec, maxVec;
+        if (mesh->mVertices) {
+            if (shortened) {
+                WriteBounds(&chunk,mesh->mVertices,mesh->mNumVertices);
+            } // else write as usual
+            else WriteArray<aiVector3D>(&chunk,mesh->mVertices,mesh->mNumVertices);
+        }
+        if (mesh->mNormals) {
+            if (shortened) {
+                WriteBounds(&chunk,mesh->mNormals,mesh->mNumVertices);
+            } // else write as usual
+            else WriteArray<aiVector3D>(&chunk,mesh->mNormals,mesh->mNumVertices);
+        }
+        if (mesh->mTangents && mesh->mBitangents) {
+            if (shortened) {
+                WriteBounds(&chunk,mesh->mTangents,mesh->mNumVertices);
+                WriteBounds(&chunk,mesh->mBitangents,mesh->mNumVertices);
+            } // else write as usual
+            else {
+                WriteArray<aiVector3D>(&chunk,mesh->mTangents,mesh->mNumVertices);
+                WriteArray<aiVector3D>(&chunk,mesh->mBitangents,mesh->mNumVertices);
             }
-            for (unsigned int n = 0; n < AI_MAX_NUMBER_OF_TEXTURECOORDS;++n) {
-                if (!mesh->mTextureCoords[n])
-                    break;
+        }
+        for (unsigned int n = 0; n < AI_MAX_NUMBER_OF_COLOR_SETS;++n) {
+            if (!mesh->mColors[n])
+                break;
 
-                // write number of UV components
-                Write<unsigned int>(&chunk,mesh->mNumUVComponents[n]);
+            if (shortened) {
+                WriteBounds(&chunk,mesh->mColors[n],mesh->mNumVertices);
+            } // else write as usual
+            else WriteArray<aiColor4D>(&chunk,mesh->mColors[n],mesh->mNumVertices);
+        }
+        for (unsigned int n = 0; n < AI_MAX_NUMBER_OF_TEXTURECOORDS;++n) {
+            if (!mesh->mTextureCoords[n])
+                break;
 
-                if (shortened) {
-                    WriteBounds(&chunk,mesh->mTextureCoords[n],mesh->mNumVertices);
-                } // else write as usual
-                else WriteArray<aiVector3D>(&chunk,mesh->mTextureCoords[n],mesh->mNumVertices);
-            }
+            // write number of UV components
+            Write<unsigned int>(&chunk,mesh->mNumUVComponents[n]);
 
-            // write faces. There are no floating-point calculations involved
-            // in these, so we can write a simple hash over the face data
-            // to the dump file. We generate a single 32 Bit hash for 512 faces
-            // using Assimp's standard hashing function.
             if (shortened) {
-                unsigned int processed = 0;
-                for (unsigned int job;(job = std::min(mesh->mNumFaces-processed,512u));processed += job) {
-
-                    uint32_t hash = 0;
-                    for (unsigned int a = 0; a < job;++a) {
+                WriteBounds(&chunk,mesh->mTextureCoords[n],mesh->mNumVertices);
+            } // else write as usual
+            else WriteArray<aiVector3D>(&chunk,mesh->mTextureCoords[n],mesh->mNumVertices);
+        }
 
-                        const aiFace& f = mesh->mFaces[processed+a];
-                        uint32_t tmp = f.mNumIndices;
+        // write faces. There are no floating-point calculations involved
+        // in these, so we can write a simple hash over the face data
+        // to the dump file. We generate a single 32 Bit hash for 512 faces
+        // using Assimp's standard hashing function.
+        if (shortened) {
+            unsigned int processed = 0;
+            for (unsigned int job;(job = std::min(mesh->mNumFaces-processed,512u));processed += job) {
+
+                uint32_t hash = 0;
+                for (unsigned int a = 0; a < job;++a) {
+
+                    const aiFace& f = mesh->mFaces[processed+a];
+                    uint32_t tmp = f.mNumIndices;
+                    hash = SuperFastHash(reinterpret_cast<const char*>(&tmp),sizeof tmp,hash);
+                    for (unsigned int i = 0; i < f.mNumIndices; ++i) {
+                        static_assert(AI_MAX_VERTICES <= 0xffffffff, "AI_MAX_VERTICES <= 0xffffffff");
+                        tmp = static_cast<uint32_t>( f.mIndices[i] );
                         hash = SuperFastHash(reinterpret_cast<const char*>(&tmp),sizeof tmp,hash);
-                        for (unsigned int i = 0; i < f.mNumIndices; ++i) {
-                            static_assert(AI_MAX_VERTICES <= 0xffffffff, "AI_MAX_VERTICES <= 0xffffffff");
-                            tmp = static_cast<uint32_t>( f.mIndices[i] );
-                            hash = SuperFastHash(reinterpret_cast<const char*>(&tmp),sizeof tmp,hash);
-                        }
                     }
-                    Write<unsigned int>(&chunk,hash);
                 }
+                Write<unsigned int>(&chunk,hash);
             }
-            else // else write as usual
-            {
-                // if there are less than 2^16 vertices, we can simply use 16 bit integers ...
-                for (unsigned int i = 0; i < mesh->mNumFaces;++i) {
-                    const aiFace& f = mesh->mFaces[i];
-
-                    static_assert(AI_MAX_FACE_INDICES <= 0xffff, "AI_MAX_FACE_INDICES <= 0xffff");
-                    Write<uint16_t>(&chunk,f.mNumIndices);
-
-                    for (unsigned int a = 0; a < f.mNumIndices;++a) {
-                        if (mesh->mNumVertices < (1u<<16)) {
-                            Write<uint16_t>(&chunk,f.mIndices[a]);
-                        }
-                        else Write<unsigned int>(&chunk,f.mIndices[a]);
+        }
+        else // else write as usual
+        {
+            // if there are less than 2^16 vertices, we can simply use 16 bit integers ...
+            for (unsigned int i = 0; i < mesh->mNumFaces;++i) {
+                const aiFace& f = mesh->mFaces[i];
+
+                static_assert(AI_MAX_FACE_INDICES <= 0xffff, "AI_MAX_FACE_INDICES <= 0xffff");
+                Write<uint16_t>(&chunk,f.mNumIndices);
+
+                for (unsigned int a = 0; a < f.mNumIndices;++a) {
+                    if (mesh->mNumVertices < (1u<<16)) {
+                        Write<uint16_t>(&chunk,f.mIndices[a]);
                     }
+                    else Write<unsigned int>(&chunk,f.mIndices[a]);
                 }
             }
+        }
 
-            // write bones
-            if (mesh->mNumBones) {
-                for (unsigned int a = 0; a < mesh->mNumBones;++a) {
-                    const aiBone* b = mesh->mBones[a];
-                    WriteBinaryBone(&chunk,b);
-                }
+        // write bones
+        if (mesh->mNumBones) {
+            for (unsigned int a = 0; a < mesh->mNumBones;++a) {
+                const aiBone* b = mesh->mBones[a];
+                WriteBinaryBone(&chunk,b);
             }
         }
+    }
 
-        // -----------------------------------------------------------------------------------
-        void WriteBinaryMaterialProperty(IOStream * container, const aiMaterialProperty* prop)
-        {
-            AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AIMATERIALPROPERTY );
+    // -----------------------------------------------------------------------------------
+    void WriteBinaryMaterialProperty(IOStream * container, const aiMaterialProperty* prop)
+    {
+        AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AIMATERIALPROPERTY );
 
-            Write<aiString>(&chunk,prop->mKey);
-            Write<unsigned int>(&chunk,prop->mSemantic);
-            Write<unsigned int>(&chunk,prop->mIndex);
+        Write<aiString>(&chunk,prop->mKey);
+        Write<unsigned int>(&chunk,prop->mSemantic);
+        Write<unsigned int>(&chunk,prop->mIndex);
 
-            Write<unsigned int>(&chunk,prop->mDataLength);
-            Write<unsigned int>(&chunk,(unsigned int)prop->mType);
-            chunk.Write(prop->mData,1,prop->mDataLength);
-        }
+        Write<unsigned int>(&chunk,prop->mDataLength);
+        Write<unsigned int>(&chunk,(unsigned int)prop->mType);
+        chunk.Write(prop->mData,1,prop->mDataLength);
+    }
 
-        // -----------------------------------------------------------------------------------
-        void WriteBinaryMaterial(IOStream * container, const aiMaterial* mat)
-        {
-            AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AIMATERIAL);
+    // -----------------------------------------------------------------------------------
+    void WriteBinaryMaterial(IOStream * container, const aiMaterial* mat)
+    {
+        AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AIMATERIAL);
 
-            Write<unsigned int>(&chunk,mat->mNumProperties);
-            for (unsigned int i = 0; i < mat->mNumProperties;++i) {
-                WriteBinaryMaterialProperty( &chunk, mat->mProperties[i]);
-            }
+        Write<unsigned int>(&chunk,mat->mNumProperties);
+        for (unsigned int i = 0; i < mat->mNumProperties;++i) {
+            WriteBinaryMaterialProperty( &chunk, mat->mProperties[i]);
         }
+    }
 
-        // -----------------------------------------------------------------------------------
-        void WriteBinaryNodeAnim(IOStream * container, const aiNodeAnim* nd)
-        {
-            AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AINODEANIM );
+    // -----------------------------------------------------------------------------------
+    void WriteBinaryNodeAnim(IOStream * container, const aiNodeAnim* nd)
+    {
+        AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AINODEANIM );
 
-            Write<aiString>(&chunk,nd->mNodeName);
-            Write<unsigned int>(&chunk,nd->mNumPositionKeys);
-            Write<unsigned int>(&chunk,nd->mNumRotationKeys);
-            Write<unsigned int>(&chunk,nd->mNumScalingKeys);
-            Write<unsigned int>(&chunk,nd->mPreState);
-            Write<unsigned int>(&chunk,nd->mPostState);
+        Write<aiString>(&chunk,nd->mNodeName);
+        Write<unsigned int>(&chunk,nd->mNumPositionKeys);
+        Write<unsigned int>(&chunk,nd->mNumRotationKeys);
+        Write<unsigned int>(&chunk,nd->mNumScalingKeys);
+        Write<unsigned int>(&chunk,nd->mPreState);
+        Write<unsigned int>(&chunk,nd->mPostState);
 
-            if (nd->mPositionKeys) {
-                if (shortened) {
-                    WriteBounds(&chunk,nd->mPositionKeys,nd->mNumPositionKeys);
+        if (nd->mPositionKeys) {
+            if (shortened) {
+                WriteBounds(&chunk,nd->mPositionKeys,nd->mNumPositionKeys);
 
-                } // else write as usual
-                else WriteArray<aiVectorKey>(&chunk,nd->mPositionKeys,nd->mNumPositionKeys);
-            }
-            if (nd->mRotationKeys) {
-                if (shortened) {
-                    WriteBounds(&chunk,nd->mRotationKeys,nd->mNumRotationKeys);
+            } // else write as usual
+            else WriteArray<aiVectorKey>(&chunk,nd->mPositionKeys,nd->mNumPositionKeys);
+        }
+        if (nd->mRotationKeys) {
+            if (shortened) {
+                WriteBounds(&chunk,nd->mRotationKeys,nd->mNumRotationKeys);
 
-                } // else write as usual
-                else WriteArray<aiQuatKey>(&chunk,nd->mRotationKeys,nd->mNumRotationKeys);
-            }
-            if (nd->mScalingKeys) {
-                if (shortened) {
-                    WriteBounds(&chunk,nd->mScalingKeys,nd->mNumScalingKeys);
+            } // else write as usual
+            else WriteArray<aiQuatKey>(&chunk,nd->mRotationKeys,nd->mNumRotationKeys);
+        }
+        if (nd->mScalingKeys) {
+            if (shortened) {
+                WriteBounds(&chunk,nd->mScalingKeys,nd->mNumScalingKeys);
 
-                } // else write as usual
-                else WriteArray<aiVectorKey>(&chunk,nd->mScalingKeys,nd->mNumScalingKeys);
-            }
+            } // else write as usual
+            else WriteArray<aiVectorKey>(&chunk,nd->mScalingKeys,nd->mNumScalingKeys);
         }
+    }
 
 
-        // -----------------------------------------------------------------------------------
-        void WriteBinaryAnim( IOStream * container, const aiAnimation* anim )
-        {
-            AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AIANIMATION );
+    // -----------------------------------------------------------------------------------
+    void WriteBinaryAnim( IOStream * container, const aiAnimation* anim )
+    {
+        AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AIANIMATION );
 
-            Write<aiString>(&chunk,anim->mName);
-            Write<double>(&chunk,anim->mDuration);
-            Write<double>(&chunk,anim->mTicksPerSecond);
-            Write<unsigned int>(&chunk,anim->mNumChannels);
+        Write<aiString>(&chunk,anim->mName);
+        Write<double>(&chunk,anim->mDuration);
+        Write<double>(&chunk,anim->mTicksPerSecond);
+        Write<unsigned int>(&chunk,anim->mNumChannels);
 
-            for (unsigned int a = 0; a < anim->mNumChannels;++a) {
-                const aiNodeAnim* nd = anim->mChannels[a];
-                WriteBinaryNodeAnim(&chunk,nd);
-            }
+        for (unsigned int a = 0; a < anim->mNumChannels;++a) {
+            const aiNodeAnim* nd = anim->mChannels[a];
+            WriteBinaryNodeAnim(&chunk,nd);
         }
+    }
 
-        // -----------------------------------------------------------------------------------
-        void WriteBinaryLight( IOStream * container, const aiLight* l )
-        {
-            AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AILIGHT );
-
-            Write<aiString>(&chunk,l->mName);
-            Write<unsigned int>(&chunk,l->mType);
-
-            if (l->mType != aiLightSource_DIRECTIONAL) {
-                Write<float>(&chunk,l->mAttenuationConstant);
-                Write<float>(&chunk,l->mAttenuationLinear);
-                Write<float>(&chunk,l->mAttenuationQuadratic);
-            }
-
-            Write<aiColor3D>(&chunk,l->mColorDiffuse);
-            Write<aiColor3D>(&chunk,l->mColorSpecular);
-            Write<aiColor3D>(&chunk,l->mColorAmbient);
+    // -----------------------------------------------------------------------------------
+    void WriteBinaryLight( IOStream * container, const aiLight* l )
+    {
+        AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AILIGHT );
 
-            if (l->mType == aiLightSource_SPOT) {
-                Write<float>(&chunk,l->mAngleInnerCone);
-                Write<float>(&chunk,l->mAngleOuterCone);
-            }
+        Write<aiString>(&chunk,l->mName);
+        Write<unsigned int>(&chunk,l->mType);
 
+        if (l->mType != aiLightSource_DIRECTIONAL) {
+            Write<float>(&chunk,l->mAttenuationConstant);
+            Write<float>(&chunk,l->mAttenuationLinear);
+            Write<float>(&chunk,l->mAttenuationQuadratic);
         }
 
-        // -----------------------------------------------------------------------------------
-        void WriteBinaryCamera( IOStream * container, const aiCamera* cam )
-        {
-            AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AICAMERA );
+        Write<aiColor3D>(&chunk,l->mColorDiffuse);
+        Write<aiColor3D>(&chunk,l->mColorSpecular);
+        Write<aiColor3D>(&chunk,l->mColorAmbient);
 
-            Write<aiString>(&chunk,cam->mName);
-            Write<aiVector3D>(&chunk,cam->mPosition);
-            Write<aiVector3D>(&chunk,cam->mLookAt);
-            Write<aiVector3D>(&chunk,cam->mUp);
-            Write<float>(&chunk,cam->mHorizontalFOV);
-            Write<float>(&chunk,cam->mClipPlaneNear);
-            Write<float>(&chunk,cam->mClipPlaneFar);
-            Write<float>(&chunk,cam->mAspect);
+        if (l->mType == aiLightSource_SPOT) {
+            Write<float>(&chunk,l->mAngleInnerCone);
+            Write<float>(&chunk,l->mAngleOuterCone);
         }
 
-        // -----------------------------------------------------------------------------------
-        void WriteBinaryScene( IOStream * container, const aiScene* scene)
-        {
-            AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AISCENE );
-
-            // basic scene information
-            Write<unsigned int>(&chunk,scene->mFlags);
-            Write<unsigned int>(&chunk,scene->mNumMeshes);
-            Write<unsigned int>(&chunk,scene->mNumMaterials);
-            Write<unsigned int>(&chunk,scene->mNumAnimations);
-            Write<unsigned int>(&chunk,scene->mNumTextures);
-            Write<unsigned int>(&chunk,scene->mNumLights);
-            Write<unsigned int>(&chunk,scene->mNumCameras);
-
-            // write node graph
-            WriteBinaryNode( &chunk, scene->mRootNode );
-
-            // write all meshes
-            for (unsigned int i = 0; i < scene->mNumMeshes;++i) {
-                const aiMesh* mesh = scene->mMeshes[i];
-                WriteBinaryMesh( &chunk,mesh);
-            }
+    }
 
-            // write materials
-            for (unsigned int i = 0; i< scene->mNumMaterials; ++i) {
-                const aiMaterial* mat = scene->mMaterials[i];
-                WriteBinaryMaterial(&chunk,mat);
-            }
+    // -----------------------------------------------------------------------------------
+    void WriteBinaryCamera( IOStream * container, const aiCamera* cam )
+    {
+        AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AICAMERA );
+
+        Write<aiString>(&chunk,cam->mName);
+        Write<aiVector3D>(&chunk,cam->mPosition);
+        Write<aiVector3D>(&chunk,cam->mLookAt);
+        Write<aiVector3D>(&chunk,cam->mUp);
+        Write<float>(&chunk,cam->mHorizontalFOV);
+        Write<float>(&chunk,cam->mClipPlaneNear);
+        Write<float>(&chunk,cam->mClipPlaneFar);
+        Write<float>(&chunk,cam->mAspect);
+    }
 
-            // write all animations
-            for (unsigned int i = 0; i < scene->mNumAnimations;++i) {
-                const aiAnimation* anim = scene->mAnimations[i];
-                WriteBinaryAnim(&chunk,anim);
-            }
+    // -----------------------------------------------------------------------------------
+    void WriteBinaryScene( IOStream * container, const aiScene* scene)
+    {
+        AssbinChunkWriter chunk( container, ASSBIN_CHUNK_AISCENE );
+
+        // basic scene information
+        Write<unsigned int>(&chunk,scene->mFlags);
+        Write<unsigned int>(&chunk,scene->mNumMeshes);
+        Write<unsigned int>(&chunk,scene->mNumMaterials);
+        Write<unsigned int>(&chunk,scene->mNumAnimations);
+        Write<unsigned int>(&chunk,scene->mNumTextures);
+        Write<unsigned int>(&chunk,scene->mNumLights);
+        Write<unsigned int>(&chunk,scene->mNumCameras);
+
+        // write node graph
+        WriteBinaryNode( &chunk, scene->mRootNode );
+
+        // write all meshes
+        for (unsigned int i = 0; i < scene->mNumMeshes;++i) {
+            const aiMesh* mesh = scene->mMeshes[i];
+            WriteBinaryMesh( &chunk,mesh);
+        }
 
+        // write materials
+        for (unsigned int i = 0; i< scene->mNumMaterials; ++i) {
+            const aiMaterial* mat = scene->mMaterials[i];
+            WriteBinaryMaterial(&chunk,mat);
+        }
 
-            // write all textures
-            for (unsigned int i = 0; i < scene->mNumTextures;++i) {
-                const aiTexture* mesh = scene->mTextures[i];
-                WriteBinaryTexture(&chunk,mesh);
-            }
+        // write all animations
+        for (unsigned int i = 0; i < scene->mNumAnimations;++i) {
+            const aiAnimation* anim = scene->mAnimations[i];
+            WriteBinaryAnim(&chunk,anim);
+        }
 
-            // write lights
-            for (unsigned int i = 0; i < scene->mNumLights;++i) {
-                const aiLight* l = scene->mLights[i];
-                WriteBinaryLight(&chunk,l);
-            }
 
-            // write cameras
-            for (unsigned int i = 0; i < scene->mNumCameras;++i) {
-                const aiCamera* cam = scene->mCameras[i];
-                WriteBinaryCamera(&chunk,cam);
-            }
+        // write all textures
+        for (unsigned int i = 0; i < scene->mNumTextures;++i) {
+            const aiTexture* mesh = scene->mTextures[i];
+            WriteBinaryTexture(&chunk,mesh);
+        }
 
+        // write lights
+        for (unsigned int i = 0; i < scene->mNumLights;++i) {
+            const aiLight* l = scene->mLights[i];
+            WriteBinaryLight(&chunk,l);
         }
 
-    public:
-        AssbinExport()
-            : shortened(false), compressed(false) // temporary settings until properties are introduced for exporters
-        {
+        // write cameras
+        for (unsigned int i = 0; i < scene->mNumCameras;++i) {
+            const aiCamera* cam = scene->mCameras[i];
+            WriteBinaryCamera(&chunk,cam);
         }
 
-        // -----------------------------------------------------------------------------------
-        // Write a binary model dump
-        void WriteBinaryDump(const char* pFile, IOSystem* pIOSystem, const aiScene* pScene)
-        {
-            IOStream * out = pIOSystem->Open( pFile, "wb" );
-            if (!out) return;
+    }
+
+public:
+    AssbinExport()
+        : shortened(false), compressed(false) // temporary settings until properties are introduced for exporters
+    {
+    }
 
-            time_t tt = time(NULL);
-            tm* p     = gmtime(&tt);
+    // -----------------------------------------------------------------------------------
+    // Write a binary model dump
+    void WriteBinaryDump(const char* pFile, IOSystem* pIOSystem, const aiScene* pScene)
+    {
+        IOStream * out = pIOSystem->Open( pFile, "wb" );
+        if (!out) return;
 
-            // header
-            char s[64];
-            memset( s, 0, 64 );
+        time_t tt = time(NULL);
+        tm* p     = gmtime(&tt);
+
+        // header
+        char s[64];
+        memset( s, 0, 64 );
 #if _MSC_VER >= 1400
-            sprintf_s(s,"ASSIMP.binary-dump.%s",asctime(p));
+        sprintf_s(s,"ASSIMP.binary-dump.%s",asctime(p));
 #else
-            ai_snprintf(s,64,"ASSIMP.binary-dump.%s",asctime(p));
+        ai_snprintf(s,64,"ASSIMP.binary-dump.%s",asctime(p));
 #endif
-            out->Write( s, 44, 1 );
-            // == 44 bytes
-
-            Write<unsigned int>( out, ASSBIN_VERSION_MAJOR );
-            Write<unsigned int>( out, ASSBIN_VERSION_MINOR );
-            Write<unsigned int>( out, aiGetVersionRevision() );
-            Write<unsigned int>( out, aiGetCompileFlags() );
-            Write<uint16_t>( out, shortened );
-            Write<uint16_t>( out, compressed );
-            // ==  20 bytes
-
-            char buff[256];
-            strncpy(buff,pFile,256);
-            out->Write(buff,sizeof(char),256);
-
-            char cmd[] = "\0";
-            strncpy(buff,cmd,128);
-            out->Write(buff,sizeof(char),128);
-
-            // leave 64 bytes free for future extensions
-            memset(buff,0xcd,64);
-            out->Write(buff,sizeof(char),64);
-            // == 435 bytes
-
-            // ==== total header size: 512 bytes
-            ai_assert( out->Tell() == ASSBIN_HEADER_LENGTH );
-
-            // Up to here the data is uncompressed. For compressed files, the rest
-            // is compressed using standard DEFLATE from zlib.
-            if (compressed)
-            {
-                AssbinChunkWriter uncompressedStream( NULL, 0 );
-                WriteBinaryScene( &uncompressedStream, pScene );
-
-                uLongf uncompressedSize = static_cast<uLongf>(uncompressedStream.Tell());
-                uLongf compressedSize = (uLongf)(uncompressedStream.Tell() * 1.001 + 12.);
-                uint8_t* compressedBuffer = new uint8_t[ compressedSize ];
-
-                compress2( compressedBuffer, &compressedSize, (const Bytef*)uncompressedStream.GetBufferPointer(), uncompressedSize, 9 );
+        out->Write( s, 44, 1 );
+        // == 44 bytes
+
+        Write<unsigned int>( out, ASSBIN_VERSION_MAJOR );
+        Write<unsigned int>( out, ASSBIN_VERSION_MINOR );
+        Write<unsigned int>( out, aiGetVersionRevision() );
+        Write<unsigned int>( out, aiGetCompileFlags() );
+        Write<uint16_t>( out, shortened );
+        Write<uint16_t>( out, compressed );
+        // ==  20 bytes
+
+        char buff[256];
+        strncpy(buff,pFile,256);
+        out->Write(buff,sizeof(char),256);
+
+        char cmd[] = "\0";
+        strncpy(buff,cmd,128);
+        out->Write(buff,sizeof(char),128);
+
+        // leave 64 bytes free for future extensions
+        memset(buff,0xcd,64);
+        out->Write(buff,sizeof(char),64);
+        // == 435 bytes
+
+        // ==== total header size: 512 bytes
+        ai_assert( out->Tell() == ASSBIN_HEADER_LENGTH );
+
+        // Up to here the data is uncompressed. For compressed files, the rest
+        // is compressed using standard DEFLATE from zlib.
+        if (compressed)
+        {
+            AssbinChunkWriter uncompressedStream( NULL, 0 );
+            WriteBinaryScene( &uncompressedStream, pScene );
 
-                out->Write( &uncompressedSize, sizeof(uint32_t), 1 );
-                out->Write( compressedBuffer, sizeof(char), compressedSize );
+            uLongf uncompressedSize = static_cast<uLongf>(uncompressedStream.Tell());
+            uLongf compressedSize = (uLongf)compressBound(uncompressedSize);
+            uint8_t* compressedBuffer = new uint8_t[ compressedSize ];
 
-                delete[] compressedBuffer;
-            }
-            else
+            int res = compress2( compressedBuffer, &compressedSize, (const Bytef*)uncompressedStream.GetBufferPointer(), uncompressedSize, 9 );
+            if(res != Z_OK)
             {
-                WriteBinaryScene( out, pScene );
+                delete [] compressedBuffer;
+                pIOSystem->Close(out);
+                throw DeadlyExportError("Compression failed.");
             }
 
-            pIOSystem->Close( out );
+            out->Write( &uncompressedSize, sizeof(uint32_t), 1 );
+            out->Write( compressedBuffer, sizeof(char), compressedSize );
+
+            delete[] compressedBuffer;
+        }
+        else
+        {
+            WriteBinaryScene( out, pScene );
         }
-    };
 
-void ExportSceneAssbin(const char* pFile, IOSystem* pIOSystem, const aiScene* pScene, const ExportProperties* /*pProperties*/)
-{
+        pIOSystem->Close( out );
+    }
+};
+
+void ExportSceneAssbin(const char* pFile, IOSystem* pIOSystem, const aiScene* pScene, const ExportProperties* /*pProperties*/) {
     AssbinExport exporter;
     exporter.WriteBinaryDump( pFile, pIOSystem, pScene );
 }

code/AssbinExporter.h

@@ -46,6 +46,13 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_ASSBINEXPORTER_H_INC
 #define AI_ASSBINEXPORTER_H_INC
 
+#include <assimp/defs.h>
+
 // nothing really needed here - reserved for future use like properties
+namespace Assimp {
+
+void ASSIMP_API ExportSceneAssbin(const char* pFile, IOSystem* pIOSystem, const aiScene* pScene, const ExportProperties* /*pProperties*/);
+
+}
 
-#endif
+#endif // AI_ASSBINEXPORTER_H_INC

code/AssbinLoader.cpp

@@ -57,6 +57,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <assimp/anim.h>
 #include <assimp/scene.h>
 #include <assimp/importerdesc.h>
+#include <memory>
 
 #ifdef ASSIMP_BUILD_NO_OWN_ZLIB
 #   include <zlib.h>
@@ -79,16 +80,17 @@ static const aiImporterDesc desc = {
     "assbin"
 };
 
-const aiImporterDesc* AssbinImporter::GetInfo() const
-{
+// -----------------------------------------------------------------------------------
+const aiImporterDesc* AssbinImporter::GetInfo() const {
     return &desc;
 }
 
-bool AssbinImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool /*checkSig*/ ) const
-{
+// -----------------------------------------------------------------------------------
+bool AssbinImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool /*checkSig*/ ) const {
     IOStream * in = pIOHandler->Open(pFile);
-    if (!in)
+    if (nullptr == in) {
         return false;
+    }
 
     char s[32];
     in->Read( s, sizeof(char), 32 );
@@ -98,17 +100,19 @@ bool AssbinImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bo
     return strncmp( s, "ASSIMP.binary-dump.", 19 ) == 0;
 }
 
+// -----------------------------------------------------------------------------------
 template <typename T>
-T Read(IOStream * stream)
-{
+T Read(IOStream * stream) {
     T t;
-    stream->Read( &t, sizeof(T), 1 );
+    size_t res = stream->Read( &t, sizeof(T), 1 );
+    if(res != 1)
+        throw DeadlyImportError("Unexpected EOF");
     return t;
 }
 
+// -----------------------------------------------------------------------------------
 template <>
-aiVector3D Read<aiVector3D>(IOStream * stream)
-{
+aiVector3D Read<aiVector3D>(IOStream * stream) {
     aiVector3D v;
     v.x = Read<float>(stream);
     v.y = Read<float>(stream);
@@ -116,9 +120,9 @@ aiVector3D Read<aiVector3D>(IOStream * stream)
     return v;
 }
 
+// -----------------------------------------------------------------------------------
 template <>
-aiColor4D Read<aiColor4D>(IOStream * stream)
-{
+aiColor4D Read<aiColor4D>(IOStream * stream) {
     aiColor4D c;
     c.r = Read<float>(stream);
     c.g = Read<float>(stream);
@@ -127,9 +131,9 @@ aiColor4D Read<aiColor4D>(IOStream * stream)
     return c;
 }
 
+// -----------------------------------------------------------------------------------
 template <>
-aiQuaternion Read<aiQuaternion>(IOStream * stream)
-{
+aiQuaternion Read<aiQuaternion>(IOStream * stream) {
     aiQuaternion v;
     v.w = Read<float>(stream);
     v.x = Read<float>(stream);
@@ -138,28 +142,29 @@ aiQuaternion Read<aiQuaternion>(IOStream * stream)
     return v;
 }
 
+// -----------------------------------------------------------------------------------
 template <>
-aiString Read<aiString>(IOStream * stream)
-{
+aiString Read<aiString>(IOStream * stream) {
     aiString s;
     stream->Read(&s.length,4,1);
-    stream->Read(s.data,s.length,1);
+    if(s.length)
+        stream->Read(s.data,s.length,1);
     s.data[s.length] = 0;
     return s;
 }
 
+// -----------------------------------------------------------------------------------
 template <>
-aiVertexWeight Read<aiVertexWeight>(IOStream * stream)
-{
+aiVertexWeight Read<aiVertexWeight>(IOStream * stream) {
     aiVertexWeight w;
     w.mVertexId = Read<unsigned int>(stream);
     w.mWeight = Read<float>(stream);
     return w;
 }
 
+// -----------------------------------------------------------------------------------
 template <>
-aiMatrix4x4 Read<aiMatrix4x4>(IOStream * stream)
-{
+aiMatrix4x4 Read<aiMatrix4x4>(IOStream * stream) {
     aiMatrix4x4 m;
     for (unsigned int i = 0; i < 4;++i) {
         for (unsigned int i2 = 0; i2 < 4;++i2) {
@@ -169,76 +174,85 @@ aiMatrix4x4 Read<aiMatrix4x4>(IOStream * stream)
     return m;
 }
 
+// -----------------------------------------------------------------------------------
 template <>
-aiVectorKey Read<aiVectorKey>(IOStream * stream)
-{
+aiVectorKey Read<aiVectorKey>(IOStream * stream) {
     aiVectorKey v;
     v.mTime = Read<double>(stream);
     v.mValue = Read<aiVector3D>(stream);
     return v;
 }
 
+// -----------------------------------------------------------------------------------
 template <>
-aiQuatKey Read<aiQuatKey>(IOStream * stream)
-{
+aiQuatKey Read<aiQuatKey>(IOStream * stream) {
     aiQuatKey v;
     v.mTime = Read<double>(stream);
     v.mValue = Read<aiQuaternion>(stream);
     return v;
 }
 
+// -----------------------------------------------------------------------------------
 template <typename T>
-void ReadArray(IOStream * stream, T * out, unsigned int size)
-{
-    for (unsigned int i=0; i<size; i++) out[i] = Read<T>(stream);
+void ReadArray( IOStream *stream, T * out, unsigned int size) {
+    ai_assert( nullptr != stream );
+    ai_assert( nullptr != out );
+
+    for (unsigned int i=0; i<size; i++) {
+        out[i] = Read<T>(stream);
+    }
 }
 
-template <typename T> void ReadBounds( IOStream * stream, T* /*p*/, unsigned int n )
-{
+// -----------------------------------------------------------------------------------
+template <typename T>
+void ReadBounds( IOStream * stream, T* /*p*/, unsigned int n ) {
     // not sure what to do here, the data isn't really useful.
     stream->Seek( sizeof(T) * n, aiOrigin_CUR );
 }
 
-void AssbinImporter::ReadBinaryNode( IOStream * stream, aiNode** node, aiNode* parent ) {
-    uint32_t chunkID = Read<uint32_t>(stream);
-    (void)(chunkID);
-    ai_assert(chunkID == ASSBIN_CHUNK_AINODE);
+// -----------------------------------------------------------------------------------
+void AssbinImporter::ReadBinaryNode( IOStream * stream, aiNode** onode, aiNode* parent ) {
+    if(Read<uint32_t>(stream) != ASSBIN_CHUNK_AINODE)
+        throw DeadlyImportError("Magic chunk identifiers are wrong!");
     /*uint32_t size =*/ Read<uint32_t>(stream);
 
-    *node = new aiNode();
+    std::unique_ptr<aiNode> node(new aiNode());
 
-    (*node)->mName = Read<aiString>(stream);
-    (*node)->mTransformation = Read<aiMatrix4x4>(stream);
-    (*node)->mNumChildren = Read<unsigned int>(stream);
-    (*node)->mNumMeshes = Read<unsigned int>(stream);
+    node->mName = Read<aiString>(stream);
+    node->mTransformation = Read<aiMatrix4x4>(stream);
+    unsigned numChildren = Read<unsigned int>(stream);
+    unsigned numMeshes = Read<unsigned int>(stream);
 	unsigned int nb_metadata = Read<unsigned int>(stream);
 
     if(parent) {
-        (*node)->mParent = parent;
+        node->mParent = parent;
     }
 
-    if ((*node)->mNumMeshes) {
-        (*node)->mMeshes = new unsigned int[(*node)->mNumMeshes];
-        for (unsigned int i = 0; i < (*node)->mNumMeshes; ++i) {
-            (*node)->mMeshes[i] = Read<unsigned int>(stream);
+    if (numMeshes)
+    {
+        node->mMeshes = new unsigned int[numMeshes];
+        for (unsigned int i = 0; i < numMeshes; ++i) {
+            node->mMeshes[i] = Read<unsigned int>(stream);
+            node->mNumMeshes++;
         }
     }
 
-    if ((*node)->mNumChildren) {
-        (*node)->mChildren = new aiNode*[(*node)->mNumChildren];
-        for (unsigned int i = 0; i < (*node)->mNumChildren; ++i) {
-            ReadBinaryNode( stream, &(*node)->mChildren[i], *node );
+    if (numChildren) {
+        node->mChildren = new aiNode*[numChildren];
+        for (unsigned int i = 0; i < numChildren; ++i) {
+            ReadBinaryNode( stream, &node->mChildren[i], node.get() );
+            node->mNumChildren++;
         }
     }
 
     if ( nb_metadata > 0 ) {
-        (*node)->mMetaData = aiMetadata::Alloc(nb_metadata);
+        node->mMetaData = aiMetadata::Alloc(nb_metadata);
         for (unsigned int i = 0; i < nb_metadata; ++i) {
-            (*node)->mMetaData->mKeys[i] = Read<aiString>(stream);
-            (*node)->mMetaData->mValues[i].mType = (aiMetadataType) Read<uint16_t>(stream);
-            void* data( nullptr );
+            node->mMetaData->mKeys[i] = Read<aiString>(stream);
+            node->mMetaData->mValues[i].mType = (aiMetadataType) Read<uint16_t>(stream);
+            void* data = nullptr;
 
-            switch ((*node)->mMetaData->mValues[i].mType) {
+            switch (node->mMetaData->mValues[i].mType) {
                 case AI_BOOL:
                     data = new bool(Read<bool>(stream));
                     break;
@@ -267,17 +281,16 @@ void AssbinImporter::ReadBinaryNode( IOStream * stream, aiNode** node, aiNode* p
                     break;
             }
 
-			(*node)->mMetaData->mValues[i].mData = data;
+			node->mMetaData->mValues[i].mData = data;
 		}
 	}
+    *onode = node.release();
 }
 
 // -----------------------------------------------------------------------------------
-void AssbinImporter::ReadBinaryBone( IOStream * stream, aiBone* b )
-{
-    uint32_t chunkID = Read<uint32_t>(stream);
-    (void)(chunkID);
-    ai_assert(chunkID == ASSBIN_CHUNK_AIBONE);
+void AssbinImporter::ReadBinaryBone( IOStream * stream, aiBone* b ) {
+    if(Read<uint32_t>(stream) != ASSBIN_CHUNK_AIBONE)
+        throw DeadlyImportError("Magic chunk identifiers are wrong!");
     /*uint32_t size =*/ Read<uint32_t>(stream);
 
     b->mName = Read<aiString>(stream);
@@ -286,23 +299,23 @@ void AssbinImporter::ReadBinaryBone( IOStream * stream, aiBone* b )
 
     // for the moment we write dumb min/max values for the bones, too.
     // maybe I'll add a better, hash-like solution later
-    if (shortened)
-    {
+    if (shortened) {
         ReadBounds(stream,b->mWeights,b->mNumWeights);
-    } // else write as usual
-    else
-    {
+    } else {
+        // else write as usual
         b->mWeights = new aiVertexWeight[b->mNumWeights];
         ReadArray<aiVertexWeight>(stream,b->mWeights,b->mNumWeights);
     }
 }
 
-
-void AssbinImporter::ReadBinaryMesh( IOStream * stream, aiMesh* mesh )
-{
-    uint32_t chunkID = Read<uint32_t>(stream);
-    (void)(chunkID);
-    ai_assert(chunkID == ASSBIN_CHUNK_AIMESH);
+// -----------------------------------------------------------------------------------
+static bool fitsIntoUI16(unsigned int mNumVertices) {
+    return ( mNumVertices < (1u<<16) );
+}
+// -----------------------------------------------------------------------------------
+void AssbinImporter::ReadBinaryMesh( IOStream * stream, aiMesh* mesh ) {
+    if(Read<uint32_t>(stream) != ASSBIN_CHUNK_AIMESH)
+        throw DeadlyImportError("Magic chunk identifiers are wrong!");
     /*uint32_t size =*/ Read<uint32_t>(stream);
 
     mesh->mPrimitiveTypes = Read<unsigned int>(stream);
@@ -314,70 +327,61 @@ void AssbinImporter::ReadBinaryMesh( IOStream * stream, aiMesh* mesh )
     // first of all, write bits for all existent vertex components
     unsigned int c = Read<unsigned int>(stream);
 
-    if (c & ASSBIN_MESH_HAS_POSITIONS)
-    {
+    if (c & ASSBIN_MESH_HAS_POSITIONS) {
         if (shortened) {
             ReadBounds(stream,mesh->mVertices,mesh->mNumVertices);
-        } // else write as usual
-        else
-        {
+        }  else {
+            // else write as usual
             mesh->mVertices = new aiVector3D[mesh->mNumVertices];
             ReadArray<aiVector3D>(stream,mesh->mVertices,mesh->mNumVertices);
         }
     }
-    if (c & ASSBIN_MESH_HAS_NORMALS)
-    {
+    if (c & ASSBIN_MESH_HAS_NORMALS) {
         if (shortened) {
             ReadBounds(stream,mesh->mNormals,mesh->mNumVertices);
-        } // else write as usual
-        else
-        {
+        }  else {
+            // else write as usual
             mesh->mNormals = new aiVector3D[mesh->mNumVertices];
             ReadArray<aiVector3D>(stream,mesh->mNormals,mesh->mNumVertices);
         }
     }
-    if (c & ASSBIN_MESH_HAS_TANGENTS_AND_BITANGENTS)
-    {
+    if (c & ASSBIN_MESH_HAS_TANGENTS_AND_BITANGENTS) {
         if (shortened) {
             ReadBounds(stream,mesh->mTangents,mesh->mNumVertices);
             ReadBounds(stream,mesh->mBitangents,mesh->mNumVertices);
-        } // else write as usual
-        else
-        {
+        }  else {
+            // else write as usual
             mesh->mTangents = new aiVector3D[mesh->mNumVertices];
             ReadArray<aiVector3D>(stream,mesh->mTangents,mesh->mNumVertices);
             mesh->mBitangents = new aiVector3D[mesh->mNumVertices];
             ReadArray<aiVector3D>(stream,mesh->mBitangents,mesh->mNumVertices);
         }
     }
-    for (unsigned int n = 0; n < AI_MAX_NUMBER_OF_COLOR_SETS;++n)
-    {
-        if (!(c & ASSBIN_MESH_HAS_COLOR(n)))
+    for (unsigned int n = 0; n < AI_MAX_NUMBER_OF_COLOR_SETS;++n) {
+        if (!(c & ASSBIN_MESH_HAS_COLOR(n))) {
             break;
+        }
 
-        if (shortened)
-        {
+        if (shortened) {
             ReadBounds(stream,mesh->mColors[n],mesh->mNumVertices);
-        } // else write as usual
-        else
-        {
+        }  else {
+            // else write as usual
             mesh->mColors[n] = new aiColor4D[mesh->mNumVertices];
             ReadArray<aiColor4D>(stream,mesh->mColors[n],mesh->mNumVertices);
         }
     }
-    for (unsigned int n = 0; n < AI_MAX_NUMBER_OF_TEXTURECOORDS;++n)
-    {
-        if (!(c & ASSBIN_MESH_HAS_TEXCOORD(n)))
+    for (unsigned int n = 0; n < AI_MAX_NUMBER_OF_TEXTURECOORDS;++n) {
+        if (!(c & ASSBIN_MESH_HAS_TEXCOORD(n))) {
             break;
+        }
 
         // write number of UV components
         mesh->mNumUVComponents[n] = Read<unsigned int>(stream);
 
         if (shortened) {
             ReadBounds(stream,mesh->mTextureCoords[n],mesh->mNumVertices);
-        } // else write as usual
-        else
-        {
+        }  else {
+            // else write as usual
             mesh->mTextureCoords[n] = new aiVector3D[mesh->mNumVertices];
             ReadArray<aiVector3D>(stream,mesh->mTextureCoords[n],mesh->mNumVertices);
         }
@@ -389,9 +393,8 @@ void AssbinImporter::ReadBinaryMesh( IOStream * stream, aiMesh* mesh )
     // using Assimp's standard hashing function.
     if (shortened) {
         Read<unsigned int>(stream);
-    }
-    else // else write as usual
-    {
+    } else  {
+        // else write as usual
         // if there are less than 2^16 vertices, we can simply use 16 bit integers ...
         mesh->mFaces = new aiFace[mesh->mNumFaces];
         for (unsigned int i = 0; i < mesh->mNumFaces;++i) {
@@ -402,12 +405,10 @@ void AssbinImporter::ReadBinaryMesh( IOStream * stream, aiMesh* mesh )
             f.mIndices = new unsigned int[f.mNumIndices];
 
             for (unsigned int a = 0; a < f.mNumIndices;++a) {
-                if (mesh->mNumVertices < (1u<<16))
-                {
+                // Check if unsigned  short ( 16 bit  ) are big enought for the indices
+                if ( fitsIntoUI16( mesh->mNumVertices ) ) {
                     f.mIndices[a] = Read<uint16_t>(stream);
-                }
-                else
-                {
+                } else {
                     f.mIndices[a] = Read<unsigned int>(stream);
                 }
             }
@@ -424,11 +425,10 @@ void AssbinImporter::ReadBinaryMesh( IOStream * stream, aiMesh* mesh )
     }
 }
 
-void AssbinImporter::ReadBinaryMaterialProperty(IOStream * stream, aiMaterialProperty* prop)
-{
-    uint32_t chunkID = Read<uint32_t>(stream);
-    (void)(chunkID);
-    ai_assert(chunkID == ASSBIN_CHUNK_AIMATERIALPROPERTY);
+// -----------------------------------------------------------------------------------
+void AssbinImporter::ReadBinaryMaterialProperty(IOStream * stream, aiMaterialProperty* prop) {
+    if(Read<uint32_t>(stream) != ASSBIN_CHUNK_AIMATERIALPROPERTY)
+        throw DeadlyImportError("Magic chunk identifiers are wrong!");
     /*uint32_t size =*/ Read<uint32_t>(stream);
 
     prop->mKey = Read<aiString>(stream);
@@ -442,11 +442,9 @@ void AssbinImporter::ReadBinaryMaterialProperty(IOStream * stream, aiMaterialPro
 }
 
 // -----------------------------------------------------------------------------------
-void AssbinImporter::ReadBinaryMaterial(IOStream * stream, aiMaterial* mat)
-{
-    uint32_t chunkID = Read<uint32_t>(stream);
-    (void)(chunkID);
-    ai_assert(chunkID == ASSBIN_CHUNK_AIMATERIAL);
+void AssbinImporter::ReadBinaryMaterial(IOStream * stream, aiMaterial* mat) {
+    if(Read<uint32_t>(stream) != ASSBIN_CHUNK_AIMATERIAL)
+        throw DeadlyImportError("Magic chunk identifiers are wrong!");
     /*uint32_t size =*/ Read<uint32_t>(stream);
 
     mat->mNumAllocated = mat->mNumProperties = Read<unsigned int>(stream);
@@ -465,11 +463,9 @@ void AssbinImporter::ReadBinaryMaterial(IOStream * stream, aiMaterial* mat)
 }
 
 // -----------------------------------------------------------------------------------
-void AssbinImporter::ReadBinaryNodeAnim(IOStream * stream, aiNodeAnim* nd)
-{
-    uint32_t chunkID = Read<uint32_t>(stream);
-    (void)(chunkID);
-    ai_assert(chunkID == ASSBIN_CHUNK_AINODEANIM);
+void AssbinImporter::ReadBinaryNodeAnim(IOStream * stream, aiNodeAnim* nd) {
+    if(Read<uint32_t>(stream) != ASSBIN_CHUNK_AINODEANIM)
+        throw DeadlyImportError("Magic chunk identifiers are wrong!");
     /*uint32_t size =*/ Read<uint32_t>(stream);
 
     nd->mNodeName = Read<aiString>(stream);
@@ -493,9 +489,8 @@ void AssbinImporter::ReadBinaryNodeAnim(IOStream * stream, aiNodeAnim* nd)
         if (shortened) {
             ReadBounds(stream,nd->mRotationKeys,nd->mNumRotationKeys);
 
-        } // else write as usual
-        else
-        {
+        }  else {
+            // else write as usual
             nd->mRotationKeys = new aiQuatKey[nd->mNumRotationKeys];
             ReadArray<aiQuatKey>(stream,nd->mRotationKeys,nd->mNumRotationKeys);
         }
@@ -504,22 +499,18 @@ void AssbinImporter::ReadBinaryNodeAnim(IOStream * stream, aiNodeAnim* nd)
         if (shortened) {
             ReadBounds(stream,nd->mScalingKeys,nd->mNumScalingKeys);
 
-        } // else write as usual
-        else
-        {
+        }  else {
+            // else write as usual
             nd->mScalingKeys = new aiVectorKey[nd->mNumScalingKeys];
             ReadArray<aiVectorKey>(stream,nd->mScalingKeys,nd->mNumScalingKeys);
         }
     }
 }
 
-
 // -----------------------------------------------------------------------------------
-void AssbinImporter::ReadBinaryAnim( IOStream * stream, aiAnimation* anim )
-{
-    uint32_t chunkID = Read<uint32_t>(stream);
-    (void)(chunkID);
-    ai_assert(chunkID == ASSBIN_CHUNK_AIANIMATION);
+void AssbinImporter::ReadBinaryAnim( IOStream * stream, aiAnimation* anim ) {
+    if(Read<uint32_t>(stream) != ASSBIN_CHUNK_AIANIMATION)
+        throw DeadlyImportError("Magic chunk identifiers are wrong!");
     /*uint32_t size =*/ Read<uint32_t>(stream);
 
     anim->mName = Read<aiString> (stream);
@@ -527,8 +518,7 @@ void AssbinImporter::ReadBinaryAnim( IOStream * stream, aiAnimation* anim )
     anim->mTicksPerSecond = Read<double> (stream);
     anim->mNumChannels = Read<unsigned int>(stream);
 
-    if (anim->mNumChannels)
-    {
+    if (anim->mNumChannels) {
         anim->mChannels = new aiNodeAnim*[ anim->mNumChannels ];
         for (unsigned int a = 0; a < anim->mNumChannels;++a) {
             anim->mChannels[a] = new aiNodeAnim();
@@ -537,11 +527,10 @@ void AssbinImporter::ReadBinaryAnim( IOStream * stream, aiAnimation* anim )
     }
 }
 
-void AssbinImporter::ReadBinaryTexture(IOStream * stream, aiTexture* tex)
-{
-    uint32_t chunkID = Read<uint32_t>(stream);
-    (void)(chunkID);
-    ai_assert(chunkID == ASSBIN_CHUNK_AITEXTURE);
+// -----------------------------------------------------------------------------------
+void AssbinImporter::ReadBinaryTexture(IOStream * stream, aiTexture* tex) {
+    if(Read<uint32_t>(stream) != ASSBIN_CHUNK_AITEXTURE)
+        throw DeadlyImportError("Magic chunk identifiers are wrong!");
     /*uint32_t size =*/ Read<uint32_t>(stream);
 
     tex->mWidth = Read<unsigned int>(stream);
@@ -552,21 +541,17 @@ void AssbinImporter::ReadBinaryTexture(IOStream * stream, aiTexture* tex)
         if (!tex->mHeight) {
             tex->pcData = new aiTexel[ tex->mWidth ];
             stream->Read(tex->pcData,1,tex->mWidth);
-        }
-        else {
+        } else {
             tex->pcData = new aiTexel[ tex->mWidth*tex->mHeight ];
             stream->Read(tex->pcData,1,tex->mWidth*tex->mHeight*4);
         }
     }
-
 }
 
 // -----------------------------------------------------------------------------------
-void AssbinImporter::ReadBinaryLight( IOStream * stream, aiLight* l )
-{
-    uint32_t chunkID = Read<uint32_t>(stream);
-    (void)(chunkID);
-    ai_assert(chunkID == ASSBIN_CHUNK_AILIGHT);
+void AssbinImporter::ReadBinaryLight( IOStream * stream, aiLight* l ) {
+    if(Read<uint32_t>(stream) != ASSBIN_CHUNK_AILIGHT)
+        throw DeadlyImportError("Magic chunk identifiers are wrong!");
     /*uint32_t size =*/ Read<uint32_t>(stream);
 
     l->mName = Read<aiString>(stream);
@@ -586,15 +571,12 @@ void AssbinImporter::ReadBinaryLight( IOStream * stream, aiLight* l )
         l->mAngleInnerCone = Read<float>(stream);
         l->mAngleOuterCone = Read<float>(stream);
     }
-
 }
 
 // -----------------------------------------------------------------------------------
-void AssbinImporter::ReadBinaryCamera( IOStream * stream, aiCamera* cam )
-{
-    uint32_t chunkID = Read<uint32_t>(stream);
-    (void)(chunkID);
-    ai_assert(chunkID == ASSBIN_CHUNK_AICAMERA);
+void AssbinImporter::ReadBinaryCamera( IOStream * stream, aiCamera* cam ) {
+    if(Read<uint32_t>(stream) != ASSBIN_CHUNK_AICAMERA)
+        throw DeadlyImportError("Magic chunk identifiers are wrong!");
     /*uint32_t size =*/ Read<uint32_t>(stream);
 
     cam->mName = Read<aiString>(stream);
@@ -607,11 +589,10 @@ void AssbinImporter::ReadBinaryCamera( IOStream * stream, aiCamera* cam )
     cam->mAspect = Read<float>(stream);
 }
 
-void AssbinImporter::ReadBinaryScene( IOStream * stream, aiScene* scene )
-{
-    uint32_t chunkID = Read<uint32_t>(stream);
-    (void)(chunkID);
-    ai_assert(chunkID == ASSBIN_CHUNK_AISCENE);
+// -----------------------------------------------------------------------------------
+void AssbinImporter::ReadBinaryScene( IOStream * stream, aiScene* scene ) {
+    if(Read<uint32_t>(stream) != ASSBIN_CHUNK_AISCENE)
+        throw DeadlyImportError("Magic chunk identifiers are wrong!");
     /*uint32_t size =*/ Read<uint32_t>(stream);
 
     scene->mFlags         = Read<unsigned int>(stream);
@@ -623,13 +604,13 @@ void AssbinImporter::ReadBinaryScene( IOStream * stream, aiScene* scene )
     scene->mNumCameras    = Read<unsigned int>(stream);
 
     // Read node graph
-    scene->mRootNode = new aiNode[1];
+    //scene->mRootNode = new aiNode[1];
     ReadBinaryNode( stream, &scene->mRootNode, (aiNode*)NULL );
 
     // Read all meshes
-    if (scene->mNumMeshes)
-    {
+    if (scene->mNumMeshes) {
         scene->mMeshes = new aiMesh*[scene->mNumMeshes];
+        memset(scene->mMeshes, 0, scene->mNumMeshes*sizeof(aiMesh*));
         for (unsigned int i = 0; i < scene->mNumMeshes;++i) {
             scene->mMeshes[i] = new aiMesh();
             ReadBinaryMesh( stream,scene->mMeshes[i]);
@@ -637,9 +618,9 @@ void AssbinImporter::ReadBinaryScene( IOStream * stream, aiScene* scene )
     }
 
     // Read materials
-    if (scene->mNumMaterials)
-    {
+    if (scene->mNumMaterials) {
         scene->mMaterials = new aiMaterial*[scene->mNumMaterials];
+        memset(scene->mMaterials, 0, scene->mNumMaterials*sizeof(aiMaterial*));
         for (unsigned int i = 0; i< scene->mNumMaterials; ++i) {
             scene->mMaterials[i] = new aiMaterial();
             ReadBinaryMaterial(stream,scene->mMaterials[i]);
@@ -647,9 +628,9 @@ void AssbinImporter::ReadBinaryScene( IOStream * stream, aiScene* scene )
     }
 
     // Read all animations
-    if (scene->mNumAnimations)
-    {
+    if (scene->mNumAnimations) {
         scene->mAnimations = new aiAnimation*[scene->mNumAnimations];
+        memset(scene->mAnimations, 0, scene->mNumAnimations*sizeof(aiAnimation*));
         for (unsigned int i = 0; i < scene->mNumAnimations;++i) {
             scene->mAnimations[i] = new aiAnimation();
             ReadBinaryAnim(stream,scene->mAnimations[i]);
@@ -657,9 +638,9 @@ void AssbinImporter::ReadBinaryScene( IOStream * stream, aiScene* scene )
     }
 
     // Read all textures
-    if (scene->mNumTextures)
-    {
+    if (scene->mNumTextures) {
         scene->mTextures = new aiTexture*[scene->mNumTextures];
+        memset(scene->mTextures, 0, scene->mNumTextures*sizeof(aiTexture*));
         for (unsigned int i = 0; i < scene->mNumTextures;++i) {
             scene->mTextures[i] = new aiTexture();
             ReadBinaryTexture(stream,scene->mTextures[i]);
@@ -667,9 +648,9 @@ void AssbinImporter::ReadBinaryScene( IOStream * stream, aiScene* scene )
     }
 
     // Read lights
-    if (scene->mNumLights)
-    {
+    if (scene->mNumLights) {
         scene->mLights = new aiLight*[scene->mNumLights];
+        memset(scene->mLights, 0, scene->mNumLights*sizeof(aiLight*));
         for (unsigned int i = 0; i < scene->mNumLights;++i) {
             scene->mLights[i] = new aiLight();
             ReadBinaryLight(stream,scene->mLights[i]);
@@ -677,9 +658,9 @@ void AssbinImporter::ReadBinaryScene( IOStream * stream, aiScene* scene )
     }
 
     // Read cameras
-    if (scene->mNumCameras)
-    {
+    if (scene->mNumCameras) {
         scene->mCameras = new aiCamera*[scene->mNumCameras];
+        memset(scene->mCameras, 0, scene->mNumCameras*sizeof(aiCamera*));
         for (unsigned int i = 0; i < scene->mNumCameras;++i) {
             scene->mCameras[i] = new aiCamera();
             ReadBinaryCamera(stream,scene->mCameras[i]);
@@ -688,16 +669,22 @@ void AssbinImporter::ReadBinaryScene( IOStream * stream, aiScene* scene )
 
 }
 
-void AssbinImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler )
-{
+// -----------------------------------------------------------------------------------
+void AssbinImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler ) {
     IOStream * stream = pIOHandler->Open(pFile,"rb");
-    if (!stream)
+    if (nullptr == stream) {
         return;
+    }
 
-    stream->Seek( 44, aiOrigin_CUR ); // signature
+    // signature
+    stream->Seek( 44, aiOrigin_CUR );
+
+    unsigned int versionMajor = Read<unsigned int>(stream);
+    unsigned int versionMinor = Read<unsigned int>(stream);
+    if (versionMinor != ASSBIN_VERSION_MINOR || versionMajor != ASSBIN_VERSION_MAJOR) {
+        throw DeadlyImportError( "Invalid version, data format not compatible!" );
+    }
 
-    /*unsigned int versionMajor =*/ Read<unsigned int>(stream);
-    /*unsigned int versionMinor =*/ Read<unsigned int>(stream);
     /*unsigned int versionRevision =*/ Read<unsigned int>(stream);
     /*unsigned int compileFlags =*/ Read<unsigned int>(stream);
 
@@ -711,17 +698,24 @@ void AssbinImporter::InternReadFile( const std::string& pFile, aiScene* pScene,
     stream->Seek( 128, aiOrigin_CUR ); // options
     stream->Seek( 64, aiOrigin_CUR ); // padding
 
-    if (compressed)
-    {
+    if (compressed) {
         uLongf uncompressedSize = Read<uint32_t>(stream);
         uLongf compressedSize = static_cast<uLongf>(stream->FileSize() - stream->Tell());
 
         unsigned char * compressedData = new unsigned char[ compressedSize ];
-        stream->Read( compressedData, 1, compressedSize );
+        size_t len = stream->Read( compressedData, 1, compressedSize );
+        ai_assert(len == compressedSize);
 
         unsigned char * uncompressedData = new unsigned char[ uncompressedSize ];
 
-        uncompress( uncompressedData, &uncompressedSize, compressedData, compressedSize );
+        int res = uncompress( uncompressedData, &uncompressedSize, compressedData, len );
+        if(res != Z_OK)
+        {
+            delete [] uncompressedData;
+            delete [] compressedData;
+            pIOHandler->Close(stream);
+            throw DeadlyImportError("Zlib decompression failed.");
+        }
 
         MemoryIOStream io( uncompressedData, uncompressedSize );
 
@@ -729,9 +723,7 @@ void AssbinImporter::InternReadFile( const std::string& pFile, aiScene* pScene,
 
         delete[] uncompressedData;
         delete[] compressedData;
-    }
-    else
-    {
+    } else {
         ReadBinaryScene(stream,pScene);
     }
 

code/AssbinLoader.h

@@ -70,32 +70,33 @@ namespace Assimp    {
 class AssbinImporter : public BaseImporter
 {
 private:
-  bool shortened;
-  bool compressed;
+    bool shortened;
+    bool compressed;
 
 public:
-  virtual bool CanRead(
-    const std::string& pFile,
-    IOSystem* pIOHandler,
-    bool checkSig
+    virtual bool CanRead(
+        const std::string& pFile,
+        IOSystem* pIOHandler,
+        bool checkSig
     ) const;
-  virtual const aiImporterDesc* GetInfo() const;
-  virtual void InternReadFile(
+    virtual const aiImporterDesc* GetInfo() const;
+    virtual void InternReadFile(
     const std::string& pFile,
-    aiScene* pScene,
-    IOSystem* pIOHandler
+        aiScene* pScene,
+        IOSystem* pIOHandler
     );
-  void ReadBinaryScene( IOStream * stream, aiScene* pScene );
-  void ReadBinaryNode( IOStream * stream, aiNode** mRootNode, aiNode* parent );
-  void ReadBinaryMesh( IOStream * stream, aiMesh* mesh );
-  void ReadBinaryBone( IOStream * stream, aiBone* bone );
-  void ReadBinaryMaterial(IOStream * stream, aiMaterial* mat);
-  void ReadBinaryMaterialProperty(IOStream * stream, aiMaterialProperty* prop);
-  void ReadBinaryNodeAnim(IOStream * stream, aiNodeAnim* nd);
-  void ReadBinaryAnim( IOStream * stream, aiAnimation* anim );
-  void ReadBinaryTexture(IOStream * stream, aiTexture* tex);
-  void ReadBinaryLight( IOStream * stream, aiLight* l );
-  void ReadBinaryCamera( IOStream * stream, aiCamera* cam );
+    void ReadHeader();
+    void ReadBinaryScene( IOStream * stream, aiScene* pScene );
+    void ReadBinaryNode( IOStream * stream, aiNode** mRootNode, aiNode* parent );
+    void ReadBinaryMesh( IOStream * stream, aiMesh* mesh );
+    void ReadBinaryBone( IOStream * stream, aiBone* bone );
+    void ReadBinaryMaterial(IOStream * stream, aiMaterial* mat);
+    void ReadBinaryMaterialProperty(IOStream * stream, aiMaterialProperty* prop);
+    void ReadBinaryNodeAnim(IOStream * stream, aiNodeAnim* nd);
+    void ReadBinaryAnim( IOStream * stream, aiAnimation* anim );
+    void ReadBinaryTexture(IOStream * stream, aiTexture* tex);
+    void ReadBinaryLight( IOStream * stream, aiLight* l );
+    void ReadBinaryCamera( IOStream * stream, aiCamera* cam );
 };
 
 } // end of namespace Assimp

code/Assimp.cpp

@@ -50,13 +50,14 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <assimp/Importer.hpp>
 #include <assimp/importerdesc.h>
 #include <assimp/scene.h>
-
 #include <assimp/GenericProperty.h>
+#include <assimp/Exceptional.h>
+#include <assimp/BaseImporter.h>
+
 #include "CInterfaceIOWrapper.h"
 #include "Importer.h"
-#include <assimp/Exceptional.h>
 #include "ScenePrivate.h"
-#include <assimp/BaseImporter.h>
+
 #include <list>
 
 // ------------------------------------------------------------------------------------------------
@@ -107,7 +108,6 @@ namespace Assimp {
 static std::mutex gLogStreamMutex;
 #endif
 
-
 // ------------------------------------------------------------------------------------------------
 // Custom LogStream implementation for the C-API
 class LogToCallbackRedirector : public LogStream {
@@ -272,8 +272,6 @@ void aiReleaseImport( const aiScene* pScene)
 
     ASSIMP_BEGIN_EXCEPTION_REGION();
 
-    aiReleaseDefaultMaterial();
-
     // find the importer associated with this data
     const ScenePrivateData* priv = ScenePriv(pScene);
     if( !priv || !priv->mOrigImporter)  {

code/BaseImporter.cpp

@@ -65,7 +65,7 @@ using namespace Assimp;
 
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
-BaseImporter::BaseImporter()
+BaseImporter::BaseImporter() AI_NO_EXCEPT
 : m_progress() {
     // nothing to do here
 }

code/BaseProcess.cpp

@@ -53,7 +53,7 @@ using namespace Assimp;
 
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
-BaseProcess::BaseProcess()
+BaseProcess::BaseProcess() AI_NO_EXCEPT
 : shared()
 , progress()
 {

code/BaseProcess.h

@@ -211,20 +211,16 @@ private:
  * should be executed. If the function returns true, the class' Execute()
  * function is called subsequently.
  */
-class ASSIMP_API_WINONLY BaseProcess
-{
+class ASSIMP_API_WINONLY BaseProcess {
     friend class Importer;
 
 public:
-
     /** Constructor to be privately used by Importer */
-    BaseProcess();
+    BaseProcess() AI_NO_EXCEPT;
 
     /** Destructor, private as well */
     virtual ~BaseProcess();
 
-public:
-
     // -------------------------------------------------------------------
     /** Returns whether the processing step is present in the given flag.
      * @param pFlags The processing flags the importer was called with. A

code/BlenderDNA.inl

@@ -405,7 +405,7 @@ bool Structure::ReadFieldPtrVector(vector<TOUT<T>>&out, const char* name, const
 	++db.stats().fields_read;
 #endif
 
-	return false;
+	return true;
 }
 
 

code/BlenderLoader.cpp

@@ -1206,7 +1206,7 @@ aiCamera* BlenderImporter::ConvertCamera(const Scene& /*in*/, const Object* obj,
     out->mUp = aiVector3D(0.f, 1.f, 0.f);
     out->mLookAt = aiVector3D(0.f, 0.f, -1.f);
     if (cam->sensor_x && cam->lens) {
-        out->mHorizontalFOV = std::atan2(cam->sensor_x,  2.f * cam->lens);
+        out->mHorizontalFOV = 2.f * std::atan2(cam->sensor_x,  2.f * cam->lens);
     }
     out->mClipPlaneNear = cam->clipsta;
     out->mClipPlaneFar = cam->clipend;

code/BlenderScene.cpp

@@ -203,7 +203,7 @@ template <> void Structure :: Convert<Lamp> (
     int temp = 0;
     ReadField<ErrorPolicy_Fail>(temp,"type",db);
     dest.type = static_cast<Assimp::Blender::Lamp::Type>(temp);
-    ReadField<ErrorPolicy_Igno>(dest.flags,"flags",db);
+    ReadField<ErrorPolicy_Igno>(dest.flags,"flag",db);
     ReadField<ErrorPolicy_Igno>(dest.colormodel,"colormodel",db);
     ReadField<ErrorPolicy_Igno>(dest.totex,"totex",db);
     ReadField<ErrorPolicy_Warn>(dest.r,"r",db);

code/CMakeLists.txt

@@ -191,6 +191,14 @@ SET( Common_SRCS
 )
 SOURCE_GROUP(Common FILES ${Common_SRCS})
 
+SET( STEPParser_SRCS
+  Importer/STEPParser/STEPFileReader.h
+  Importer/STEPParser/STEPFileReader.cpp
+  Importer/STEPParser/STEPFileEncoding.cpp
+  Importer/STEPParser/STEPFileEncoding.h
+)
+SOURCE_GROUP(STEPParser FILES ${STEPParser_SRCS})
+
 IF ( ASSIMP_BUILD_NONFREE_C4D_IMPORTER )
   SET( C4D_SRCS
     C4DImporter.cpp
@@ -487,11 +495,8 @@ ADD_ASSIMP_IMPORTER( IFC
   Importer/IFC/IFCCurve.cpp
   Importer/IFC/IFCBoolean.cpp
   Importer/IFC/IFCOpenings.cpp
-  Importer/IFC/STEPFileReader.h
-  Importer/IFC/STEPFileReader.cpp
-  Importer/IFC/STEPFileEncoding.cpp
-  Importer/IFC/STEPFileEncoding.h
 )
+
 if (ASSIMP_BUILD_IFC_IMPORTER)
   if (MSVC)
     set_source_files_properties(Importer/IFC/IFCReaderGen1_2x3.cpp Importer/IFC/IFCReaderGen2_2x3.cpp PROPERTIES COMPILE_FLAGS "/bigobj")
@@ -505,7 +510,6 @@ ADD_ASSIMP_IMPORTER( XGL
   XGLLoader.h
 )
 
-
 ADD_ASSIMP_IMPORTER( FBX
   FBXImporter.cpp
   FBXCompileConfig.h
@@ -558,6 +562,8 @@ SET( PostProcessing_SRCS
   FindInvalidDataProcess.h
   FixNormalsStep.cpp
   FixNormalsStep.h
+  DropFaceNormalsProcess.cpp
+  DropFaceNormalsProcess.h
   GenFaceNormalsProcess.cpp
   GenFaceNormalsProcess.h
   GenVertexNormalsProcess.cpp
@@ -722,9 +728,15 @@ ADD_ASSIMP_IMPORTER( MMD
 )
 
 SET( Step_SRCS
-  STEPFile.h
-  StepExporter.h
-  StepExporter.cpp
+    STEPFile.h
+    Importer/StepFile/StepFileImporter.h
+    Importer/StepFile/StepFileImporter.cpp
+    Importer/StepFile/StepFileGen1.cpp
+    Importer/StepFile/StepFileGen2.cpp
+    Importer/StepFile/StepFileGen3.cpp
+    Importer/StepFile/StepReaderGen.h
+    StepExporter.h
+    StepExporter.cpp
 )
 SOURCE_GROUP( Step FILES ${Step_SRCS})
 
@@ -878,6 +890,7 @@ SET( assimp_src
   ${Exporter_SRCS}
   ${PostProcessing_SRCS}
   ${MaterialSystem_SRCS}
+  ${STEPParser_SRCS}
   ${Step_SRCS}
 
   # Model Support
@@ -910,6 +923,7 @@ IF (ASSIMP_BUILD_NONFREE_C4D_IMPORTER)
 ENDIF (ASSIMP_BUILD_NONFREE_C4D_IMPORTER)
 
 ADD_LIBRARY( assimp ${assimp_src} )
+ADD_LIBRARY(assimp::assimp ALIAS assimp)
 
 TARGET_INCLUDE_DIRECTORIES ( assimp PUBLIC
   $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/../include>

code/COBLoader.cpp

@@ -137,9 +137,7 @@ void COBImporter::SetupProperties(const Importer* /*pImp*/)
 
 // ------------------------------------------------------------------------------------------------
 // Imports the given file into the given scene structure.
-void COBImporter::InternReadFile( const std::string& pFile,
-    aiScene* pScene, IOSystem* pIOHandler)
-{
+void COBImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler) {
     COB::Scene scene;
     std::unique_ptr<StreamReaderLE> stream(new StreamReaderLE( pIOHandler->Open(pFile,"rb")) );
 

code/ColladaExporter.cpp

@@ -1533,7 +1533,23 @@ void ColladaExporter::WriteNode( const aiScene* pScene, aiNode* pNode)
 
     // write transformation - we can directly put the matrix there
     // TODO: (thom) decompose into scale - rot - quad to allow addressing it by animations afterwards
-    const aiMatrix4x4& mat = pNode->mTransformation;
+    aiMatrix4x4 mat = pNode->mTransformation;
+
+    // If this node is a Camera node, the camera coordinate system needs to be multiplied in.
+    // When importing from Collada, the mLookAt is set to 0, 0, -1, and the node transform is unchanged.
+    // When importing from a different format, mLookAt is set to 0, 0, 1. Therefore, the local camera
+    // coordinate system must be changed to matche the Collada specification.
+    for (size_t i = 0; i<mScene->mNumCameras; i++){
+        if (mScene->mCameras[i]->mName == pNode->mName){
+            aiMatrix4x4 sourceView;
+            mScene->mCameras[i]->GetCameraMatrix(sourceView);
+
+            aiMatrix4x4 colladaView;
+            colladaView.a1 = colladaView.c3 = -1; // move into -z space.
+            mat *= (sourceView * colladaView);
+            break;
+        }
+    }
 	
 	// customized, sid should be 'matrix' to match with loader code.
     //mOutput << startstr << "<matrix sid=\"transform\">";

code/D3MFImporter.cpp

@@ -297,8 +297,9 @@ private:
             return false;
         }
 
+        //format of the color string: #RRGGBBAA or #RRGGBB (3MF Core chapter 5.1.1)
         const size_t len( strlen( color ) );
-        if ( 9 != len ) {
+        if ( 9 != len && 7 != len) {
             return false;
         }
 
@@ -313,26 +314,28 @@ private:
         ++buf;
         comp[ 1 ] = *buf;
         ++buf;
-        diffuse.r = static_cast<ai_real>( strtol( comp, NULL, 16 ) );
+        diffuse.r = static_cast<ai_real>( strtol( comp, NULL, 16 ) ) / ai_real(255.0);
 
 
         comp[ 0 ] = *buf;
         ++buf;
         comp[ 1 ] = *buf;
         ++buf;
-        diffuse.g = static_cast< ai_real >( strtol( comp, NULL, 16 ) );
+        diffuse.g = static_cast< ai_real >( strtol( comp, NULL, 16 ) ) / ai_real(255.0);
 
         comp[ 0 ] = *buf;
         ++buf;
         comp[ 1 ] = *buf;
         ++buf;
-        diffuse.b = static_cast< ai_real >( strtol( comp, NULL, 16 ) );
+        diffuse.b = static_cast< ai_real >( strtol( comp, NULL, 16 ) ) / ai_real(255.0);
 
+        if(7 == len)
+            return true;
         comp[ 0 ] = *buf;
         ++buf;
         comp[ 1 ] = *buf;
         ++buf;
-        diffuse.a = static_cast< ai_real >( strtol( comp, NULL, 16 ) );
+        diffuse.a = static_cast< ai_real >( strtol( comp, NULL, 16 ) ) / ai_real(255.0);
 
         return true;
     }
@@ -416,8 +419,6 @@ private:
 
 } //namespace D3MF
 
-static const std::string Extension = "3mf";
-
 static const aiImporterDesc desc = {
     "3mf Importer",
     "",
@@ -428,7 +429,7 @@ static const aiImporterDesc desc = {
     0,
     0,
     0,
-    Extension.c_str()
+    "3mf"
 };
 
 D3MFImporter::D3MFImporter()
@@ -442,7 +443,7 @@ D3MFImporter::~D3MFImporter() {
 
 bool D3MFImporter::CanRead(const std::string &filename, IOSystem *pIOHandler, bool checkSig) const {
     const std::string extension( GetExtension( filename ) );
-    if(extension == Extension ) {
+    if(extension == desc.mFileExtensions ) {
         return true;
     } else if ( !extension.length() || checkSig ) {
         if ( nullptr == pIOHandler ) {

code/DXFHelper.h

@@ -55,28 +55,21 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <assimp/DefaultLogger.hpp>
 
 namespace Assimp {
-    namespace DXF {
-
+namespace DXF {
 
 // read pairs of lines, parse group code and value and provide utilities
 // to convert the data to the target data type.
-class LineReader
-{
-
+// do NOT skip empty lines. In DXF files, they count as valid data.
+class LineReader {
 public:
-
     LineReader(StreamReaderLE& reader)
-         // do NOT skip empty lines. In DXF files, they count as valid data.
-        : splitter(reader,false,true)
-        , groupcode( 0 )
-        , value()
-        , end()
-    {
+    : splitter(reader,false,true)
+    , groupcode( 0 )
+    , value()
+    , end() {
+        // empty
     }
 
-public:
-
-
     // -----------------------------------------
     bool Is(int gc, const char* what) const {
         return groupcode == gc && !strcmp(what,value.c_str());
@@ -102,8 +95,6 @@ public:
         return !((bool)*this);
     }
 
-public:
-
     // -----------------------------------------
     unsigned int ValueAsUnsignedInt() const {
         return strtoul10(value.c_str());
@@ -119,8 +110,6 @@ public:
         return fast_atof(value.c_str());
     }
 
-public:
-
     // -----------------------------------------
     /** pseudo-iterator increment to advance to the next (groupcode/value) pair */
     LineReader& operator++() {
@@ -175,14 +164,12 @@ private:
     int end;
 };
 
-
-
 // represents a POLYLINE or a LWPOLYLINE. or even a 3DFACE The data is converted as needed.
-struct PolyLine
-{
+struct PolyLine {
     PolyLine()
-        : flags()
-    {}
+    : flags() {
+        // empty
+    }
 
     std::vector<aiVector3D> positions;
     std::vector<aiColor4D>  colors;
@@ -194,14 +181,15 @@ struct PolyLine
     std::string desc;
 };
 
-
 // reference to a BLOCK. Specifies its own coordinate system.
-struct InsertBlock
-{
+struct InsertBlock {
     InsertBlock()
-        : scale(1.f,1.f,1.f)
-        , angle()
-    {}
+    : pos()
+    , scale(1.f,1.f,1.f)
+    , angle()
+    , name() {
+        // empty
+    }
 
     aiVector3D pos;
     aiVector3D scale;
@@ -228,9 +216,7 @@ struct FileData
     std::vector<Block> blocks;
 };
 
+}
+} // Namespace Assimp
 
-
-
-
-}}
 #endif

code/DXFLoader.cpp

@@ -63,16 +63,15 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 using namespace Assimp;
 
 // AutoCAD Binary DXF<CR><LF><SUB><NULL>
-#define AI_DXF_BINARY_IDENT ("AutoCAD Binary DXF\r\n\x1a\0")
-#define AI_DXF_BINARY_IDENT_LEN (24)
+const std::string AI_DXF_BINARY_IDENT = std::string("AutoCAD Binary DXF\r\n\x1a\0");
+const size_t AI_DXF_BINARY_IDENT_LEN = 24u;
 
 // default vertex color that all uncolored vertices will receive
-#define AI_DXF_DEFAULT_COLOR aiColor4D(0.6f,0.6f,0.6f,0.6f)
+const aiColor4D AI_DXF_DEFAULT_COLOR(aiColor4D(0.6f, 0.6f, 0.6f, 0.6f));
 
 // color indices for DXF - 16 are supported, the table is
 // taken directly from the DXF spec.
-static aiColor4D g_aclrDxfIndexColors[] =
-{
+static aiColor4D g_aclrDxfIndexColors[] = {
     aiColor4D (0.6f, 0.6f, 0.6f, 1.0f),
     aiColor4D (1.0f, 0.0f, 0.0f, 1.0f), // red
     aiColor4D (0.0f, 1.0f, 0.0f, 1.0f), // green
@@ -93,6 +92,10 @@ static aiColor4D g_aclrDxfIndexColors[] =
 #define AI_DXF_NUM_INDEX_COLORS (sizeof(g_aclrDxfIndexColors)/sizeof(g_aclrDxfIndexColors[0]))
 #define AI_DXF_ENTITIES_MAGIC_BLOCK "$ASSIMP_ENTITIES_MAGIC"
 
+static const int GroupCode_Name  = 2;
+static const int GroupCode_XComp = 10;
+static const int GroupCode_YComp = 20;
+static const int GroupCode_ZComp = 30;
 
 static const aiImporterDesc desc = {
     "Drawing Interchange Format (DXF) Importer",
@@ -110,24 +113,27 @@ static const aiImporterDesc desc = {
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
 DXFImporter::DXFImporter()
-{}
+: BaseImporter() {
+    // empty
+}
 
 // ------------------------------------------------------------------------------------------------
 // Destructor, private as well
-DXFImporter::~DXFImporter()
-{}
+DXFImporter::~DXFImporter() {
+    // empty
+}
 
 // ------------------------------------------------------------------------------------------------
 // Returns whether the class can handle the format of the given file.
-bool DXFImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool checkSig ) const {
-    const std::string& extension = GetExtension( pFile );
-    if ( extension == "dxf" ) {
+bool DXFImporter::CanRead( const std::string& filename, IOSystem* pIOHandler, bool checkSig ) const {
+    const std::string& extension = GetExtension( filename );
+    if ( extension == desc.mFileExtensions ) {
         return true;
     }
 
     if ( extension.empty() || checkSig ) {
-        static const char *pTokens[] = { "SECTION", "HEADER", "ENDSEC", "BLOCKS" };
-        return BaseImporter::SearchFileHeaderForToken(pIOHandler, pFile, pTokens, 4, 32 );
+        const char *pTokens[] = { "SECTION", "HEADER", "ENDSEC", "BLOCKS" };
+        return BaseImporter::SearchFileHeaderForToken(pIOHandler, filename, pTokens, 4, 32 );
     }
 
     return false;
@@ -135,29 +141,25 @@ bool DXFImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool
 
 // ------------------------------------------------------------------------------------------------
 // Get a list of all supported file extensions
-const aiImporterDesc* DXFImporter::GetInfo () const
-{
+const aiImporterDesc* DXFImporter::GetInfo () const {
     return &desc;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Imports the given file into the given scene structure.
-void DXFImporter::InternReadFile( const std::string& pFile,
-    aiScene* pScene,
-    IOSystem* pIOHandler)
-{
-    std::shared_ptr<IOStream> file = std::shared_ptr<IOStream>( pIOHandler->Open( pFile) );
+void DXFImporter::InternReadFile( const std::string& filename, aiScene* pScene, IOSystem* pIOHandler) {
+    std::shared_ptr<IOStream> file = std::shared_ptr<IOStream>( pIOHandler->Open( filename) );
 
     // Check whether we can read the file
-    if( file.get() == NULL) {
-        throw DeadlyImportError( "Failed to open DXF file " + pFile + "");
+    if( file.get() == nullptr ) {
+        throw DeadlyImportError( "Failed to open DXF file " + filename + "");
     }
 
-    // check whether this is a binaray DXF file - we can't read binary DXF files :-(
+    // Check whether this is a binary DXF file - we can't read binary DXF files :-(
     char buff[AI_DXF_BINARY_IDENT_LEN+1] = {0};
     file->Read(buff,AI_DXF_BINARY_IDENT_LEN,1);
 
-    if (!strncmp(AI_DXF_BINARY_IDENT,buff,AI_DXF_BINARY_IDENT_LEN)) {
+    if (0 == strncmp(AI_DXF_BINARY_IDENT.c_str(),buff,AI_DXF_BINARY_IDENT_LEN)) {
         throw DeadlyImportError("DXF: Binary files are not supported at the moment");
     }
 
@@ -226,13 +228,11 @@ void DXFImporter::InternReadFile( const std::string& pFile,
 }
 
 // ------------------------------------------------------------------------------------------------
-void DXFImporter::ConvertMeshes(aiScene* pScene, DXF::FileData& output)
-{
+void DXFImporter::ConvertMeshes(aiScene* pScene, DXF::FileData& output) {
     // the process of resolving all the INSERT statements can grow the
     // poly-count excessively, so log the original number.
     // XXX Option to import blocks as separate nodes?
     if (!DefaultLogger::isNullLogger()) {
-
         unsigned int vcount = 0, icount = 0;
         for (const DXF::Block& bl : output.blocks) {
             for (std::shared_ptr<const DXF::PolyLine> pl : bl.lines) {
@@ -293,7 +293,7 @@ void DXFImporter::ConvertMeshes(aiScene* pScene, DXF::FileData& output)
         }
     }
 
-    if (!pScene->mNumMeshes) {
+    if ( 0 == pScene->mNumMeshes) {
         throw DeadlyImportError("DXF: this file contains no 3d data");
     }
 
@@ -366,8 +366,7 @@ void DXFImporter::ConvertMeshes(aiScene* pScene, DXF::FileData& output)
 
 
 // ------------------------------------------------------------------------------------------------
-void DXFImporter::ExpandBlockReferences(DXF::Block& bl,const DXF::BlockMap& blocks_by_name)
-{
+void DXFImporter::ExpandBlockReferences(DXF::Block& bl,const DXF::BlockMap& blocks_by_name) {
     for (const DXF::InsertBlock& insert : bl.insertions) {
 
         // first check if the referenced blocks exists ...
@@ -407,8 +406,7 @@ void DXFImporter::ExpandBlockReferences(DXF::Block& bl,const DXF::BlockMap& bloc
 }
 
 // ------------------------------------------------------------------------------------------------
-void DXFImporter::GenerateMaterials(aiScene* pScene, DXF::FileData& /*output*/)
-{
+void DXFImporter::GenerateMaterials(aiScene* pScene, DXF::FileData& /*output*/) {
     // generate an almost-white default material. Reason:
     // the default vertex color is GREY, so we are
     // already at Assimp's usual default color.
@@ -433,8 +431,7 @@ void DXFImporter::GenerateMaterials(aiScene* pScene, DXF::FileData& /*output*/)
 }
 
 // ------------------------------------------------------------------------------------------------
-void DXFImporter::GenerateHierarchy(aiScene* pScene, DXF::FileData& /*output*/)
-{
+void DXFImporter::GenerateHierarchy(aiScene* pScene, DXF::FileData& /*output*/) {
     // generate the output scene graph, which is just the root node with a single child for each layer.
     pScene->mRootNode = new aiNode();
     pScene->mRootNode->mName.Set("<DXF_ROOT>");
@@ -488,17 +485,17 @@ void DXFImporter::ParseBlock(DXF::LineReader& reader, DXF::FileData& output) {
     while( !reader.End() && !reader.Is(0,"ENDBLK")) {
 
         switch(reader.GroupCode()) {
-            case 2:
+            case GroupCode_Name:
                 block.name = reader.Value();
                 break;
 
-            case 10:
+            case GroupCode_XComp:
                 block.base.x = reader.ValueAsFloat();
                 break;
-            case 20:
+            case GroupCode_YComp:
                 block.base.y = reader.ValueAsFloat();
                 break;
-            case 30:
+            case GroupCode_ZComp:
                 block.base.z = reader.ValueAsFloat();
                 break;
         }
@@ -525,9 +522,8 @@ void DXFImporter::ParseBlock(DXF::LineReader& reader, DXF::FileData& output) {
 }
 
 // ------------------------------------------------------------------------------------------------
-void DXFImporter::ParseEntities(DXF::LineReader& reader, DXF::FileData& output)
-{
-    // push a new block onto the stack.
+void DXFImporter::ParseEntities(DXF::LineReader& reader, DXF::FileData& output) {
+    // Push a new block onto the stack.
     output.blocks.push_back( DXF::Block() );
     DXF::Block& block = output.blocks.back();
 
@@ -557,27 +553,25 @@ void DXFImporter::ParseEntities(DXF::LineReader& reader, DXF::FileData& output)
         " inserted blocks in ENTITIES" );
 }
 
-void DXFImporter::ParseInsertion(DXF::LineReader& reader, DXF::FileData& output)
-{
+void DXFImporter::ParseInsertion(DXF::LineReader& reader, DXF::FileData& output) {
     output.blocks.back().insertions.push_back( DXF::InsertBlock() );
     DXF::InsertBlock& bl = output.blocks.back().insertions.back();
 
     while( !reader.End() && !reader.Is(0)) {
-        switch(reader.GroupCode())
-        {
+        switch(reader.GroupCode()) {
             // name of referenced block
-        case 2:
+        case GroupCode_Name:
             bl.name = reader.Value();
             break;
 
             // translation
-        case 10:
+        case GroupCode_XComp:
             bl.pos.x = reader.ValueAsFloat();
             break;
-        case 20:
+        case GroupCode_YComp:
             bl.pos.y = reader.ValueAsFloat();
             break;
-        case 30:
+        case GroupCode_ZComp:
             bl.pos.z = reader.ValueAsFloat();
             break;
 
@@ -704,8 +698,7 @@ void DXFImporter::ParsePolyLine(DXF::LineReader& reader, DXF::FileData& output)
 #define DXF_VERTEX_FLAG_HAS_POSITIONS 0x40
 
 // ------------------------------------------------------------------------------------------------
-void DXFImporter::ParsePolyLineVertex(DXF::LineReader& reader, DXF::PolyLine& line)
-{
+void DXFImporter::ParsePolyLineVertex(DXF::LineReader& reader, DXF::PolyLine& line) {
     unsigned int cnti = 0, flags = 0;
     unsigned int indices[4];
 
@@ -718,8 +711,7 @@ void DXFImporter::ParsePolyLineVertex(DXF::LineReader& reader, DXF::PolyLine& li
             break;
         }
 
-        switch (reader.GroupCode())
-        {
+        switch (reader.GroupCode()) {
         case 8:
                 // layer to which the vertex belongs to - assume that
                 // this is always the layer the top-level poly-line
@@ -734,9 +726,17 @@ void DXFImporter::ParsePolyLineVertex(DXF::LineReader& reader, DXF::PolyLine& li
                 break;
 
         // VERTEX COORDINATES
-        case 10: out.x = reader.ValueAsFloat();break;
-        case 20: out.y = reader.ValueAsFloat();break;
-        case 30: out.z = reader.ValueAsFloat();break;
+        case GroupCode_XComp:
+            out.x = reader.ValueAsFloat();
+            break;
+
+        case GroupCode_YComp:
+            out.y = reader.ValueAsFloat();
+            break;
+
+        case GroupCode_ZComp:
+            out.z = reader.ValueAsFloat();
+            break;
 
         // POLYFACE vertex indices
         case 71:
@@ -770,6 +770,10 @@ void DXFImporter::ParsePolyLineVertex(DXF::LineReader& reader, DXF::PolyLine& li
             if (indices[i] == 0) {
                 ASSIMP_LOG_WARN("DXF: invalid vertex index, indices are one-based.");
                 --line.counts.back();
+                // Workaround to fix issue 2229
+                if (line.counts.back() == 0) {
+                    line.counts.pop_back();
+                }
                 continue;
             }
             line.indices.push_back(indices[i]-1);
@@ -808,62 +812,74 @@ void DXFImporter::Parse3DFace(DXF::LineReader& reader, DXF::FileData& output)
             break;
 
         // x position of the first corner
-        case 10: vip[0].x = reader.ValueAsFloat();
+        case 10:
+            vip[0].x = reader.ValueAsFloat();
             b[2] = true;
             break;
 
         // y position of the first corner
-        case 20: vip[0].y = reader.ValueAsFloat();
+        case 20:
+            vip[0].y = reader.ValueAsFloat();
             b[2] = true;
             break;
 
         // z position of the first corner
-        case 30: vip[0].z = reader.ValueAsFloat();
+        case 30:
+            vip[0].z = reader.ValueAsFloat();
             b[2] = true;
             break;
 
         // x position of the second corner
-        case 11: vip[1].x = reader.ValueAsFloat();
+        case 11:
+            vip[1].x = reader.ValueAsFloat();
             b[3] = true;
             break;
 
         // y position of the second corner
-        case 21: vip[1].y = reader.ValueAsFloat();
+        case 21:
+            vip[1].y = reader.ValueAsFloat();
             b[3] = true;
             break;
 
         // z position of the second corner
-        case 31: vip[1].z = reader.ValueAsFloat();
+        case 31:
+            vip[1].z = reader.ValueAsFloat();
             b[3] = true;
             break;
 
         // x position of the third corner
-        case 12: vip[2].x = reader.ValueAsFloat();
+        case 12:
+            vip[2].x = reader.ValueAsFloat();
             b[0] = true;
             break;
 
         // y position of the third corner
-        case 22: vip[2].y = reader.ValueAsFloat();
+        case 22:
+            vip[2].y = reader.ValueAsFloat();
             b[0] = true;
             break;
 
         // z position of the third corner
-        case 32: vip[2].z = reader.ValueAsFloat();
+        case 32:
+            vip[2].z = reader.ValueAsFloat();
             b[0] = true;
             break;
 
         // x position of the fourth corner
-        case 13: vip[3].x = reader.ValueAsFloat();
+        case 13:
+            vip[3].x = reader.ValueAsFloat();
             b[1] = true;
             break;
 
         // y position of the fourth corner
-        case 23: vip[3].y = reader.ValueAsFloat();
+        case 23:
+            vip[3].y = reader.ValueAsFloat();
             b[1] = true;
             break;
 
         // z position of the fourth corner
-        case 33: vip[3].z = reader.ValueAsFloat();
+        case 33:
+            vip[3].z = reader.ValueAsFloat();
             b[1] = true;
             break;
 

code/DXFLoader.h

@@ -50,32 +50,27 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <map>
 
 namespace Assimp    {
-    namespace DXF {
 
-        class LineReader;
-        struct FileData;
-        struct PolyLine;
-        struct Block;
-        struct InsertBlock;
-
-        typedef std::map<std::string, const DXF::Block*> BlockMap;
-    }
+// Forward declarations
+namespace DXF {
+    class LineReader;
+    struct FileData;
+    struct PolyLine;
+    struct Block;
+    struct InsertBlock;
 
+    typedef std::map<std::string, const DXF::Block*> BlockMap;
+}
 
 // ---------------------------------------------------------------------------
-/** DXF importer implementation.
- *
-*/
-class DXFImporter : public BaseImporter
-{
+/** 
+ *  @brief  DXF importer implementation.
+ */
+class DXFImporter : public BaseImporter {
 public:
     DXFImporter();
     ~DXFImporter();
 
-
-
-public:
-
     // -------------------------------------------------------------------
     /** Returns whether the class can handle the format of the given file.
     * See BaseImporter::CanRead() for details.  */
@@ -83,7 +78,6 @@ public:
         bool checkSig) const;
 
 protected:
-
     // -------------------------------------------------------------------
     /** Return importer meta information.
      * See #BaseImporter::GetInfo for the details*/

code/DefaultProgressHandler.h

@@ -52,9 +52,7 @@ namespace Assimp    {
 
 // ------------------------------------------------------------------------------------
 /** @brief Internal default implementation of the #ProgressHandler interface. */
-class DefaultProgressHandler
-    : public ProgressHandler    {
-
+class DefaultProgressHandler : public ProgressHandler    {
 
     virtual bool Update(float /*percentage*/) {
         return false;

code/DropFaceNormalsProcess.cpp

@@ -0,0 +1,109 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2018, assimp team
+
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/** @file Implementation of the post processing step to drop face
+* normals for all imported faces.
+*/
+
+
+#include "DropFaceNormalsProcess.h"
+#include <assimp/postprocess.h>
+#include <assimp/scene.h>
+#include <assimp/DefaultLogger.hpp>
+#include <assimp/Exceptional.h>
+
+using namespace Assimp;
+
+// ------------------------------------------------------------------------------------------------
+// Constructor to be privately used by Importer
+DropFaceNormalsProcess::DropFaceNormalsProcess()
+{
+    // nothing to do here
+}
+
+// ------------------------------------------------------------------------------------------------
+// Destructor, private as well
+DropFaceNormalsProcess::~DropFaceNormalsProcess()
+{
+    // nothing to do here
+}
+
+// ------------------------------------------------------------------------------------------------
+// Returns whether the processing step is present in the given flag field.
+bool DropFaceNormalsProcess::IsActive( unsigned int pFlags) const {
+    return  (pFlags & aiProcess_DropNormals) != 0;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Executes the post processing step on the given imported data.
+void DropFaceNormalsProcess::Execute( aiScene* pScene) {
+    ASSIMP_LOG_DEBUG("DropFaceNormalsProcess begin");
+
+    if (pScene->mFlags & AI_SCENE_FLAGS_NON_VERBOSE_FORMAT) {
+        throw DeadlyImportError("Post-processing order mismatch: expecting pseudo-indexed (\"verbose\") vertices here");
+    }
+
+    bool bHas = false;
+    for( unsigned int a = 0; a < pScene->mNumMeshes; a++) {
+        bHas |= this->DropMeshFaceNormals( pScene->mMeshes[a]);
+    }
+    if (bHas)   {
+        ASSIMP_LOG_INFO("DropFaceNormalsProcess finished. "
+            "Face normals have been removed");
+    } else {
+        ASSIMP_LOG_DEBUG("DropFaceNormalsProcess finished. "
+            "No normals were present");
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Executes the post processing step on the given imported data.
+bool DropFaceNormalsProcess::DropMeshFaceNormals (aiMesh* pMesh) {
+    if (NULL == pMesh->mNormals) {
+        return false;
+    }
+    
+    delete[] pMesh->mNormals;
+    pMesh->mNormals = nullptr;
+    return true;
+}

code/DropFaceNormalsProcess.h

@@ -0,0 +1,86 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2018, assimp team
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+/** @file Defines a post processing step to compute face normals for all loaded faces*/
+#ifndef AI_DROPFACENORMALPROCESS_H_INC
+#define AI_DROPFACENORMALPROCESS_H_INC
+
+#include "BaseProcess.h"
+#include <assimp/mesh.h>
+
+namespace Assimp
+{
+
+// ---------------------------------------------------------------------------
+/** The DropFaceNormalsProcess computes face normals for all faces of all meshes
+*/
+class ASSIMP_API_WINONLY DropFaceNormalsProcess : public BaseProcess
+{
+public:
+
+    DropFaceNormalsProcess();
+    ~DropFaceNormalsProcess();
+
+public:
+    // -------------------------------------------------------------------
+    /** Returns whether the processing step is present in the given flag field.
+    * @param pFlags The processing flags the importer was called with. A bitwise
+    *   combination of #aiPostProcessSteps.
+    * @return true if the process is present in this flag fields, false if not.
+    */
+    bool IsActive( unsigned int pFlags) const;
+
+    // -------------------------------------------------------------------
+    /** Executes the post processing step on the given imported data.
+    * At the moment a process is not supposed to fail.
+    * @param pScene The imported data to work at.
+    */
+    void Execute( aiScene* pScene);
+
+
+private:
+    bool DropMeshFaceNormals(aiMesh* pcMesh);
+};
+
+} // end of namespace Assimp
+
+#endif // !!AI_DROPFACENORMALPROCESS_H_INC

code/EmbedTexturesProcess.cpp

@@ -119,7 +119,7 @@ bool EmbedTexturesProcess::addTexture(aiScene* pScene, std::string path) const {
         }
     }
 
-    aiTexel* imageContent = new aiTexel[1u + imageSize / sizeof(aiTexel)];
+    aiTexel* imageContent = new aiTexel[ 1ul + static_cast<unsigned long>( imageSize ) / sizeof(aiTexel)];
     file.seekg(0, std::ios::beg);
     file.read(reinterpret_cast<char*>(imageContent), imageSize);
 

code/Exporter.cpp

@@ -56,22 +56,22 @@ Here we implement only the C++ interface (Assimp::Exporter).
 
 #include <assimp/BlobIOSystem.h>
 #include <assimp/SceneCombiner.h>
-#include "BaseProcess.h"
-#include "Importer.h" // need this for GetPostProcessingStepInstanceList()
+#include <assimp/DefaultIOSystem.h>
+#include <assimp/Exporter.hpp>
+#include <assimp/mesh.h>
+#include <assimp/postprocess.h>
+#include <assimp/scene.h>
 
+#include "DefaultProgressHandler.h"
+#include "BaseProcess.h"
 #include "JoinVerticesProcess.h"
 #include "MakeVerboseFormat.h"
 #include "ConvertToLHProcess.h"
 #include "PretransformVertices.h"
 #include <assimp/Exceptional.h>
 #include "ScenePrivate.h"
-#include <memory>
 
-#include <assimp/DefaultIOSystem.h>
-#include <assimp/Exporter.hpp>
-#include <assimp/mesh.h>
-#include <assimp/postprocess.h>
-#include <assimp/scene.h>
+#include <memory>
 
 namespace Assimp {
 
@@ -188,10 +188,14 @@ Exporter::ExportFormatEntry gExporters[] =
 class ExporterPimpl {
 public:
     ExporterPimpl()
-        : blob()
-        , mIOSystem(new Assimp::DefaultIOSystem())
-        , mIsDefaultIOHandler(true)
-    {
+    : blob()
+    , mIOSystem(new Assimp::DefaultIOSystem())
+    , mIsDefaultIOHandler(true)
+    , mProgressHandler( nullptr )
+    , mIsDefaultProgressHandler( true )
+    , mPostProcessingSteps()
+    , mError()
+    , mExporters() {
         GetPostProcessingStepInstanceList(mPostProcessingSteps);
 
         // grab all built-in exporters
@@ -201,14 +205,14 @@ public:
         }
     }
 
-    ~ExporterPimpl()
-    {
+    ~ExporterPimpl() {
         delete blob;
 
         // Delete all post-processing plug-ins
         for( unsigned int a = 0; a < mPostProcessingSteps.size(); a++) {
             delete mPostProcessingSteps[a];
         }
+        delete mProgressHandler;
     }
 
 public:
@@ -216,6 +220,10 @@ public:
     std::shared_ptr< Assimp::IOSystem > mIOSystem;
     bool mIsDefaultIOHandler;
 
+    /** The progress handler */
+    ProgressHandler *mProgressHandler;
+    bool mIsDefaultProgressHandler;
+
     /** Post processing steps we can apply at the imported data. */
     std::vector< BaseProcess* > mPostProcessingSteps;
 
@@ -233,13 +241,12 @@ using namespace Assimp;
 // ------------------------------------------------------------------------------------------------
 Exporter :: Exporter()
 : pimpl(new ExporterPimpl()) {
-    // empty
+    pimpl->mProgressHandler = new DefaultProgressHandler();
 }
 
 // ------------------------------------------------------------------------------------------------
 Exporter::~Exporter() {
     FreeBlob();
-
     delete pimpl;
 }
 
@@ -259,12 +266,32 @@ bool Exporter::IsDefaultIOHandler() const {
     return pimpl->mIsDefaultIOHandler;
 }
 
+// ------------------------------------------------------------------------------------------------
+void Exporter::SetProgressHandler(ProgressHandler* pHandler) {
+    ai_assert(nullptr != pimpl);
+
+    if ( nullptr == pHandler) {
+        // Release pointer in the possession of the caller
+        pimpl->mProgressHandler = new DefaultProgressHandler();
+        pimpl->mIsDefaultProgressHandler = true;
+        return;
+    }
+
+    if (pimpl->mProgressHandler == pHandler) {
+        return;
+    }
+
+    delete pimpl->mProgressHandler;
+    pimpl->mProgressHandler = pHandler;
+    pimpl->mIsDefaultProgressHandler = false;
+}
+
 // ------------------------------------------------------------------------------------------------
 const aiExportDataBlob* Exporter::ExportToBlob( const aiScene* pScene, const char* pFormatId,
                                                 unsigned int, const ExportProperties* /*pProperties*/ ) {
     if (pimpl->blob) {
         delete pimpl->blob;
-        pimpl->blob = NULL;
+        pimpl->blob = nullptr;
     }
 
     std::shared_ptr<IOSystem> old = pimpl->mIOSystem;
@@ -273,7 +300,7 @@ const aiExportDataBlob* Exporter::ExportToBlob( const aiScene* pScene, const cha
 
     if (AI_SUCCESS != Export(pScene,pFormatId,blobio->GetMagicFileName())) {
         pimpl->mIOSystem = old;
-        return NULL;
+        return nullptr;
     }
 
     pimpl->blob = blobio->GetBlobChain();
@@ -295,6 +322,7 @@ bool IsVerboseFormat(const aiMesh* mesh) {
             }
         }
     }
+
     return true;
 }
 
@@ -305,6 +333,7 @@ bool IsVerboseFormat(const aiScene* pScene) {
             return false;
         }
     }
+
     return true;
 }
 
@@ -319,6 +348,8 @@ aiReturn Exporter::Export( const aiScene* pScene, const char* pFormatId, const c
     // meshes upfront.
     const bool is_verbose_format = !(pScene->mFlags & AI_SCENE_FLAGS_NON_VERBOSE_FORMAT) || IsVerboseFormat(pScene);
 
+    pimpl->mProgressHandler->UpdateFileWrite(0, 4);
+
     pimpl->mError = "";
     for (size_t i = 0; i < pimpl->mExporters.size(); ++i) {
         const Exporter::ExportFormatEntry& exp = pimpl->mExporters[i];
@@ -326,9 +357,11 @@ aiReturn Exporter::Export( const aiScene* pScene, const char* pFormatId, const c
             try {
                 // Always create a full copy of the scene. We might optimize this one day,
                 // but for now it is the most pragmatic way.
-                aiScene* scenecopy_tmp = NULL;
+                aiScene* scenecopy_tmp = nullptr;
                 SceneCombiner::CopyScene(&scenecopy_tmp,pScene);
 
+                pimpl->mProgressHandler->UpdateFileWrite(1, 4);
+
                 std::unique_ptr<aiScene> scenecopy(scenecopy_tmp);
                 const ScenePrivateData* const priv = ScenePriv(pScene);
 
@@ -375,6 +408,8 @@ aiReturn Exporter::Export( const aiScene* pScene, const char* pFormatId, const c
                     }
                 }
 
+                pimpl->mProgressHandler->UpdateFileWrite(2, 4);
+
                 if (pp) {
                     // the three 'conversion' steps need to be executed first because all other steps rely on the standard data layout
                     {
@@ -418,11 +453,13 @@ aiReturn Exporter::Export( const aiScene* pScene, const char* pFormatId, const c
                         }
                     }
                     ScenePrivateData* const privOut = ScenePriv(scenecopy.get());
-                    ai_assert(privOut);
+                    ai_assert(nullptr != privOut);
 
                     privOut->mPPStepsApplied |= pp;
                 }
 
+                pimpl->mProgressHandler->UpdateFileWrite(3, 4);
+
                 if(must_join_again) {
                     JoinVerticesProcess proc;
                     proc.Execute(scenecopy.get());
@@ -430,6 +467,8 @@ aiReturn Exporter::Export( const aiScene* pScene, const char* pFormatId, const c
 
                 ExportProperties emptyProperties;  // Never pass NULL ExportProperties so Exporters don't have to worry.
                 exp.mExportFunction(pPath,pimpl->mIOSystem.get(),scenecopy.get(), pProperties ? pProperties : &emptyProperties);
+
+                pimpl->mProgressHandler->UpdateFileWrite(4, 4);
             } catch (DeadlyExportError& err) {
                 pimpl->mError = err.what();
                 return AI_FAILURE;
@@ -452,7 +491,7 @@ const char* Exporter::GetErrorString() const {
 // ------------------------------------------------------------------------------------------------
 void Exporter::FreeBlob() {
     delete pimpl->blob;
-    pimpl->blob = NULL;
+    pimpl->blob = nullptr;
 
     pimpl->mError = "";
 }
@@ -465,7 +504,7 @@ const aiExportDataBlob* Exporter::GetBlob() const {
 // ------------------------------------------------------------------------------------------------
 const aiExportDataBlob* Exporter::GetOrphanedBlob() const {
     const aiExportDataBlob* tmp = pimpl->blob;
-    pimpl->blob = NULL;
+    pimpl->blob = nullptr;
     return tmp;
 }
 
@@ -545,75 +584,63 @@ bool ExportProperties::SetPropertyString(const char* szName, const std::string&
 
 // ------------------------------------------------------------------------------------------------
 // Set a configuration property
-bool ExportProperties :: SetPropertyMatrix(const char* szName, const aiMatrix4x4& value)
-{
+bool ExportProperties::SetPropertyMatrix(const char* szName, const aiMatrix4x4& value) {
     return SetGenericProperty<aiMatrix4x4>(mMatrixProperties, szName,value);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Get a configuration property
-int ExportProperties :: GetPropertyInteger(const char* szName,
-    int iErrorReturn /*= 0xffffffff*/) const
-{
+int ExportProperties::GetPropertyInteger(const char* szName, int iErrorReturn /*= 0xffffffff*/) const {
     return GetGenericProperty<int>(mIntProperties,szName,iErrorReturn);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Get a configuration property
-ai_real ExportProperties :: GetPropertyFloat(const char* szName,
-    ai_real iErrorReturn /*= 10e10*/) const
-{
+ai_real ExportProperties::GetPropertyFloat(const char* szName, ai_real iErrorReturn /*= 10e10*/) const {
     return GetGenericProperty<ai_real>(mFloatProperties,szName,iErrorReturn);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Get a configuration property
-const std::string ExportProperties :: GetPropertyString(const char* szName,
-    const std::string& iErrorReturn /*= ""*/) const
-{
+const std::string ExportProperties::GetPropertyString(const char* szName,
+        const std::string& iErrorReturn /*= ""*/) const {
     return GetGenericProperty<std::string>(mStringProperties,szName,iErrorReturn);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Has a configuration property
-const aiMatrix4x4 ExportProperties :: GetPropertyMatrix(const char* szName,
-    const aiMatrix4x4& iErrorReturn /*= aiMatrix4x4()*/) const
-{
+const aiMatrix4x4 ExportProperties::GetPropertyMatrix(const char* szName,
+        const aiMatrix4x4& iErrorReturn /*= aiMatrix4x4()*/) const {
     return GetGenericProperty<aiMatrix4x4>(mMatrixProperties,szName,iErrorReturn);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Has a configuration property
-bool ExportProperties :: HasPropertyInteger(const char* szName) const
-{
+bool ExportProperties::HasPropertyInteger(const char* szName) const {
     return HasGenericProperty<int>(mIntProperties, szName);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Has a configuration property
-bool ExportProperties :: HasPropertyBool(const char* szName) const
-{
+bool ExportProperties::HasPropertyBool(const char* szName) const {
     return HasGenericProperty<int>(mIntProperties, szName);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Has a configuration property
-bool ExportProperties :: HasPropertyFloat(const char* szName) const
-{
+bool ExportProperties::HasPropertyFloat(const char* szName) const {
     return HasGenericProperty<ai_real>(mFloatProperties, szName);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Has a configuration property
-bool ExportProperties :: HasPropertyString(const char* szName) const
-{
+bool ExportProperties::HasPropertyString(const char* szName) const {
     return HasGenericProperty<std::string>(mStringProperties, szName);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Has a configuration property
-bool ExportProperties :: HasPropertyMatrix(const char* szName) const
-{
+bool ExportProperties::HasPropertyMatrix(const char* szName) const {
     return HasGenericProperty<aiMatrix4x4>(mMatrixProperties, szName);
 }
 

code/FBXConverter.cpp

@@ -185,12 +185,8 @@ void FBXConverter::ConvertNodes( uint64_t id, aiNode& parent, const aiMatrix4x4&
                 }
 
                 if ( !name_carrier ) {
-                    NodeNameCache::const_iterator it = mNodeNames.find(original_name);
-                    if ( it != mNodeNames.end() ) {
-                        original_name = original_name + std::string( "001" );
-                    }
-
-                    mNodeNames.insert( original_name );
+                    std::string old_original_name = original_name;
+                    GetUniqueName(old_original_name, original_name);
                     nodes_chain.push_back( new aiNode( original_name ) );
                 } else {
                     original_name = nodes_chain.back()->mName.C_Str();

code/FBXDocumentUtil.h

@@ -44,7 +44,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef INCLUDED_AI_FBX_DOCUMENT_UTIL_H
 #define INCLUDED_AI_FBX_DOCUMENT_UTIL_H
 
-#include "../include/assimp/defs.h"
+#include <assimp/defs.h>
 #include <string>
 #include <memory>
 #include "FBXDocument.h"

code/FBXMeshGeometry.cpp

@@ -437,7 +437,7 @@ void ResolveVertexDataArray(std::vector<T>& data_out, const Scope& source,
     // deal with this more elegantly and with less redundancy, but right
     // now it seems unavoidable.
     if (MappingInformationType == "ByVertice" && isDirect) {
-        if (!HasElement(source, indexDataElementName)) {
+        if (!HasElement(source, dataElementName)) {
             return;
         }
         std::vector<T> tempData;

code/FindDegenerates.cpp

@@ -91,8 +91,10 @@ void FindDegeneratesProcess::SetupProperties(const Importer* pImp) {
 // Executes the post processing step on the given imported data.
 void FindDegeneratesProcess::Execute( aiScene* pScene) {
     ASSIMP_LOG_DEBUG("FindDegeneratesProcess begin");
-    for (unsigned int i = 0; i < pScene->mNumMeshes;++i){
-        if (ExecuteOnMesh(pScene->mMeshes[i])) {
+    for (unsigned int i = 0; i < pScene->mNumMeshes;++i)
+    {
+        //Do not process point cloud, ExecuteOnMesh works only with faces data
+        if ((pScene->mMeshes[i]->mPrimitiveTypes != aiPrimitiveType::aiPrimitiveType_POINT) && ExecuteOnMesh(pScene->mMeshes[i])) {
             removeMesh(pScene, i);
             --i; //the current i is removed, do not skip the next one
         }

code/HMPFileData.h

@@ -46,7 +46,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 namespace Assimp    {
 namespace HMP   {
 
-#include "./../include/assimp/Compiler/pushpack1.h"
+#include <assimp/Compiler/pushpack1.h>
 #include <stdint.h>
 
 // to make it easier for us, we test the magic word against both "endianesses"
@@ -131,7 +131,7 @@ struct Vertex_HMP7
     int8_t normal_x,normal_y;
 } PACK_STRUCT;
 
-#include "./../include/assimp/Compiler/poppack1.h"
+#include <assimp/Compiler/poppack1.h>
 
 } //! namespace HMP
 } //! namespace Assimp

code/HalfLifeFileData.h

@@ -51,7 +51,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_MDLFILEHELPER2_H_INC
 #define AI_MDLFILEHELPER2_H_INC
 
-#include "./../include/assimp/Compiler/pushpack1.h"
+#include <assimp/Compiler/pushpack1.h>
 
 namespace Assimp    {
 namespace MDL   {
@@ -141,7 +141,7 @@ struct Header_HL2 {
     int32_t         transitionindex;
 } /* PACK_STRUCT */;
 
-#include "./../include/assimp/Compiler/poppack1.h"
+#include <assimp/Compiler/poppack1.h>
 
 }
 } // end namespaces

code/Importer.cpp

@@ -178,7 +178,6 @@ Importer::~Importer()
 {
     // Delete all import plugins
 	DeleteImporterInstanceList(pimpl->mImporter);
-    aiReleaseDefaultMaterial();
 
     // Delete all post-processing plug-ins
     for( unsigned int a = 0; a < pimpl->mPostProcessingSteps.size(); a++)
@@ -316,22 +315,19 @@ void Importer::SetIOHandler( IOSystem* pIOHandler)
 
 // ------------------------------------------------------------------------------------------------
 // Get the currently set IO handler
-IOSystem* Importer::GetIOHandler() const
-{
+IOSystem* Importer::GetIOHandler() const {
     return pimpl->mIOHandler;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Check whether a custom IO handler is currently set
-bool Importer::IsDefaultIOHandler() const
-{
+bool Importer::IsDefaultIOHandler() const {
     return pimpl->mIsDefaultHandler;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Supplies a custom progress handler to get regular callbacks during importing
-void Importer::SetProgressHandler ( ProgressHandler* pHandler )
-{
+void Importer::SetProgressHandler ( ProgressHandler* pHandler ) {
     ASSIMP_BEGIN_EXCEPTION_REGION();
     // If the new handler is zero, allocate a default implementation.
     if (!pHandler)
@@ -352,15 +348,13 @@ void Importer::SetProgressHandler ( ProgressHandler* pHandler )
 
 // ------------------------------------------------------------------------------------------------
 // Get the currently set progress handler
-ProgressHandler* Importer::GetProgressHandler() const
-{
+ProgressHandler* Importer::GetProgressHandler() const {
     return pimpl->mProgressHandler;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Check whether a custom progress handler is currently set
-bool Importer::IsDefaultProgressHandler() const
-{
+bool Importer::IsDefaultProgressHandler() const {
     return pimpl->mIsDefaultProgressHandler;
 }
 
@@ -385,7 +379,6 @@ void Importer::FreeScene( )
 {
     ASSIMP_BEGIN_EXCEPTION_REGION();
 
-    aiReleaseDefaultMaterial();
     delete pimpl->mScene;
     pimpl->mScene = NULL;
 

code/Importer.h

@@ -120,11 +120,11 @@ public:
     SharedPostProcessInfo* mPPShared;
 
     /// The default class constructor.
-    ImporterPimpl();
+    ImporterPimpl() AI_NO_EXCEPT;
 };
 
 inline
-ImporterPimpl::ImporterPimpl()
+ImporterPimpl::ImporterPimpl() AI_NO_EXCEPT
 : mIOHandler( nullptr )
 , mIsDefaultHandler( false )
 , mProgressHandler( nullptr )

code/Importer/IFC/IFCLoader.cpp

@@ -56,7 +56,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #endif
 
 #include "IFCLoader.h"
-#include "STEPFileReader.h"
+#include "../STEPParser/STEPFileReader.h"
 
 #include "IFCUtil.h"
 
@@ -134,7 +134,7 @@ IFCImporter::~IFCImporter()
 bool IFCImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool checkSig) const
 {
     const std::string& extension = GetExtension(pFile);
-    if (extension == "ifc" || extension == "ifczip" || extension == "stp" ) {
+    if (extension == "ifc" || extension == "ifczip" ) {
         return true;
     } else if ((!extension.length() || checkSig) && pIOHandler)   {
         // note: this is the common identification for STEP-encoded files, so

code/Importer/IFC/IFCReaderGen_4.cpp

@@ -43,7 +43,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef ASSIMP_BUILD_NO_IFC_IMPORTER
 
 #include "AssimpPCH.h"
-#include "IFCReaderGen4.h"
+#include "IFCReaderGen_4.h"
 
 namespace Assimp {
 using namespace IFC;

code/Importer/IFC/STEPFileReader.cpp → code/Importer/STEPParser/STEPFileReader.cpp

@@ -85,16 +85,16 @@ STEP::TypeError::TypeError (const std::string& s,uint64_t entity /* = ENTITY_NOT
 
 }
 
-
+static const char *ISO_Token         = "ISO-10303-21;";
+static const char *FILE_SCHEMA_Token = "FILE_SCHEMA";
 // ------------------------------------------------------------------------------------------------
-STEP::DB* STEP::ReadFileHeader(std::shared_ptr<IOStream> stream)
-{
+STEP::DB* STEP::ReadFileHeader(std::shared_ptr<IOStream> stream) {
     std::shared_ptr<StreamReaderLE> reader = std::shared_ptr<StreamReaderLE>(new StreamReaderLE(stream));
     std::unique_ptr<STEP::DB> db = std::unique_ptr<STEP::DB>(new STEP::DB(reader));
 
-    LineSplitter& splitter = db->GetSplitter();
-    if (!splitter || *splitter != "ISO-10303-21;") {
-        throw STEP::SyntaxError("expected magic token: ISO-10303-21",1);
+    LineSplitter &splitter = db->GetSplitter();
+    if (!splitter || *splitter != ISO_Token ) {
+        throw STEP::SyntaxError("expected magic token: " + std::string( ISO_Token ), 1);
     }
 
     HeaderInfo& head = db->GetHeader();
@@ -109,7 +109,7 @@ STEP::DB* STEP::ReadFileHeader(std::shared_ptr<IOStream> stream)
         // want one-based line numbers for human readers, so +1
         const uint64_t line = splitter.get_index()+1;
 
-        if (s.substr(0,11) == "FILE_SCHEMA") {
+        if (s.substr(0,11) == FILE_SCHEMA_Token) {
             const char* sz = s.c_str()+11;
             SkipSpaces(sz,&sz);
             std::shared_ptr< const EXPRESS::DataType > schema = EXPRESS::DataType::Parse(sz);
@@ -549,4 +549,3 @@ void STEP::LazyObject::LazyInit() const
     // store the original id in the object instance
     obj->SetID(id);
 }
-

code/Importer/IFC/STEPFileReader.h → code/Importer/STEPParser/STEPFileReader.h

@@ -48,18 +48,23 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 namespace Assimp {
 namespace STEP {
 
-    // ### Parsing a STEP file is a twofold procedure ###
-    // --------------------------------------------------------------------------
-    // 1) read file header and return to caller, who checks if the
-    //    file is of a supported schema ..
-    DB* ReadFileHeader(std::shared_ptr<IOStream> stream);
-    // --------------------------------------------------------------------------
-    // 2) read the actual file contents using a user-supplied set of
-    //    conversion functions to interpret the data.
-    void ReadFile(DB& db,const EXPRESS::ConversionSchema& scheme, const char* const* types_to_track, size_t len, const char* const* inverse_indices_to_track, size_t len2);
-    template <size_t N, size_t N2> inline void ReadFile(DB& db,const EXPRESS::ConversionSchema& scheme, const char* const (&arr)[N], const char* const (&arr2)[N2]) {
-        return ReadFile(db,scheme,arr,N,arr2,N2);
-    }
+// --------------------------------------------------------------------------
+/// @brief  Parsing a STEP file is a twofold procedure.
+/// 1) read file header and return to caller, who checks if the
+///    file is of a supported schema ..
+DB* ReadFileHeader(std::shared_ptr<IOStream> stream);
+
+/// 2) read the actual file contents using a user-supplied set of
+///    conversion functions to interpret the data.
+void ReadFile(DB& db,const EXPRESS::ConversionSchema& scheme, const char* const* types_to_track, size_t len, const char* const* inverse_indices_to_track, size_t len2);
+
+/// @brief  Helper to read a file.
+template <size_t N, size_t N2>
+inline
+void ReadFile(DB& db,const EXPRESS::ConversionSchema& scheme, const char* const (&arr)[N], const char* const (&arr2)[N2]) {
+    return ReadFile(db,scheme,arr,N,arr2,N2);
+}
+
 } // ! STEP
 } // ! Assimp
 

code/Importer/StepFile/StepFileGen1.cpp

@@ -0,0 +1,2195 @@
+/*
+Open Asset Import Library (ASSIMP)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2018, ASSIMP Development Team
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms, 
+with or without modification, are permitted provided that the 
+following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the ASSIMP team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the ASSIMP Development Team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+/** MACHINE-GENERATED by scripts/ICFImporter/CppGenerator.py */
+
+#ifndef ASSIMP_BUILD_NO_STEPFILE_IMPORTER
+
+#include "code/Importer/StepFile/StepReaderGen.h"
+
+namespace Assimp {
+using namespace StepFile;
+
+namespace {
+
+	typedef EXPRESS::ConversionSchema::SchemaEntry SchemaEntry;
+
+	const SchemaEntry schema_raw[] =  {
+		SchemaEntry("absorbed_dose_measure",NULL )
+,		SchemaEntry("acceleration_measure",NULL )
+,		SchemaEntry("action_items",NULL )
+,		SchemaEntry("action_method_items",NULL )
+,		SchemaEntry("action_request_item",NULL )
+,		SchemaEntry("ahead_or_behind",NULL )
+,		SchemaEntry("amount_of_substance_measure",NULL )
+,		SchemaEntry("angle_direction_reference_select",NULL )
+,		SchemaEntry("angle_direction_reference_with_a2p3d_select",NULL )
+,		SchemaEntry("angle_relator",NULL )
+,		SchemaEntry("annotation_plane_element",NULL )
+,		SchemaEntry("annotation_representation_select",NULL )
+,		SchemaEntry("annotation_symbol_occurrence_item",NULL )
+,		SchemaEntry("annotation_text_occurrence_item",NULL )
+,		SchemaEntry("approval_item",NULL )
+,		SchemaEntry("approved_item",NULL )
+,		SchemaEntry("area_measure",NULL )
+,		SchemaEntry("area_or_view",NULL )
+,		SchemaEntry("attribute_classification_item",NULL )
+,		SchemaEntry("attribute_language_item",NULL )
+,		SchemaEntry("attribute_type",NULL )
+,		SchemaEntry("axis2_placement",NULL )
+,		SchemaEntry("b_spline_curve_form",NULL )
+,		SchemaEntry("b_spline_surface_form",NULL )
+,		SchemaEntry("base_solid_select",NULL )
+,		SchemaEntry("blend_end_condition_select",NULL )
+,		SchemaEntry("blend_radius_variation_type",NULL )
+,		SchemaEntry("boolean_operand",NULL )
+,		SchemaEntry("boolean_operator",NULL )
+,		SchemaEntry("box_characteristic_select",NULL )
+,		SchemaEntry("box_height",NULL )
+,		SchemaEntry("box_rotate_angle",NULL )
+,		SchemaEntry("box_slant_angle",NULL )
+,		SchemaEntry("box_width",NULL )
+,		SchemaEntry("camera_model_d3_multi_clipping_interection_select",NULL )
+,		SchemaEntry("camera_model_d3_multi_clipping_union_select",NULL )
+,		SchemaEntry("capacitance_measure",NULL )
+,		SchemaEntry("category_usage_item",NULL )
+,		SchemaEntry("cc_classified_item",NULL )
+,		SchemaEntry("cc_person_organization_item",NULL )
+,		SchemaEntry("cc_specified_item",NULL )
+,		SchemaEntry("celsius_temperature_measure",NULL )
+,		SchemaEntry("central_or_parallel",NULL )
+,		SchemaEntry("certification_item",NULL )
+,		SchemaEntry("certified_item",NULL )
+,		SchemaEntry("change_request_item",NULL )
+,		SchemaEntry("character_spacing_select",NULL )
+,		SchemaEntry("character_style_select",NULL )
+,		SchemaEntry("characterized_action_definition",NULL )
+,		SchemaEntry("characterized_definition",NULL )
+,		SchemaEntry("characterized_material_property",NULL )
+,		SchemaEntry("characterized_product_composition_value",NULL )
+,		SchemaEntry("characterized_product_definition",NULL )
+,		SchemaEntry("class_usage_effectivity_context_item",NULL )
+,		SchemaEntry("classification_item",NULL )
+,		SchemaEntry("classified_item",NULL )
+,		SchemaEntry("compound_item_definition",NULL )
+,		SchemaEntry("conductance_measure",NULL )
+,		SchemaEntry("configuration_design_item",NULL )
+,		SchemaEntry("configured_effectivity_context_item",NULL )
+,		SchemaEntry("configured_effectivity_item",NULL )
+,		SchemaEntry("constructive_geometry_representation_or_shape_represenation",NULL )
+,		SchemaEntry("context_dependent_measure",NULL )
+,		SchemaEntry("contract_item",NULL )
+,		SchemaEntry("contracted_item",NULL )
+,		SchemaEntry("count_measure",NULL )
+,		SchemaEntry("csg_primitive",NULL )
+,		SchemaEntry("csg_select",NULL )
+,		SchemaEntry("curve_font_or_scaled_curve_font_select",NULL )
+,		SchemaEntry("curve_on_surface",NULL )
+,		SchemaEntry("curve_or_annotation_curve_occurrence",NULL )
+,		SchemaEntry("curve_or_render",NULL )
+,		SchemaEntry("curve_style_font_select",NULL )
+,		SchemaEntry("date_and_time_item",NULL )
+,		SchemaEntry("date_item",NULL )
+,		SchemaEntry("date_time_item",NULL )
+,		SchemaEntry("date_time_or_event_occurrence",NULL )
+,		SchemaEntry("date_time_select",NULL )
+,		SchemaEntry("day_in_month_number",NULL )
+,		SchemaEntry("day_in_week_number",NULL )
+,		SchemaEntry("day_in_year_number",NULL )
+,		SchemaEntry("defined_symbol_select",NULL )
+,		SchemaEntry("derived_property_select",NULL )
+,		SchemaEntry("description_attribute_select",NULL )
+,		SchemaEntry("descriptive_measure",NULL )
+,		SchemaEntry("dimension_count",NULL )
+,		SchemaEntry("dimension_extent_usage",NULL )
+,		SchemaEntry("dimensional_characteristic",NULL )
+,		SchemaEntry("direction_count_select",NULL )
+,		SchemaEntry("document_identifier_assigned_item",NULL )
+,		SchemaEntry("document_reference_item",NULL )
+,		SchemaEntry("dose_equivalent_measure",NULL )
+,		SchemaEntry("draughting_callout_element",NULL )
+,		SchemaEntry("draughting_model_item_association_select",NULL )
+,		SchemaEntry("draughting_model_item_select",NULL )
+,		SchemaEntry("draughting_titled_item",NULL )
+,		SchemaEntry("effectivity_item",NULL )
+,		SchemaEntry("electric_charge_measure",NULL )
+,		SchemaEntry("electric_current_measure",NULL )
+,		SchemaEntry("electric_potential_measure",NULL )
+,		SchemaEntry("energy_measure",NULL )
+,		SchemaEntry("event_occurrence_item",NULL )
+,		SchemaEntry("external_identification_item",NULL )
+,		SchemaEntry("fill_area_style_tile_shape_select",NULL )
+,		SchemaEntry("fill_style_select",NULL )
+,		SchemaEntry("font_select",NULL )
+,		SchemaEntry("force_measure",NULL )
+,		SchemaEntry("founded_item_select",NULL )
+,		SchemaEntry("frequency_measure",NULL )
+,		SchemaEntry("generalized_surface_select",NULL )
+,		SchemaEntry("geometric_item_specific_usage_select",NULL )
+,		SchemaEntry("geometric_set_select",NULL )
+,		SchemaEntry("groupable_item",NULL )
+,		SchemaEntry("hour_in_day",NULL )
+,		SchemaEntry("id_attribute_select",NULL )
+,		SchemaEntry("identification_item",NULL )
+,		SchemaEntry("identifier",NULL )
+,		SchemaEntry("illuminance_measure",NULL )
+,		SchemaEntry("inductance_measure",NULL )
+,		SchemaEntry("instance_usage_context_select",NULL )
+,		SchemaEntry("invisibility_context",NULL )
+,		SchemaEntry("invisible_item",NULL )
+,		SchemaEntry("ir_usage_item",NULL )
+,		SchemaEntry("knot_type",NULL )
+,		SchemaEntry("label",NULL )
+,		SchemaEntry("layered_item",NULL )
+,		SchemaEntry("length_measure",NULL )
+,		SchemaEntry("limit_condition",NULL )
+,		SchemaEntry("list_of_reversible_topology_item",NULL )
+,		SchemaEntry("list_representation_item",NULL )
+,		SchemaEntry("luminous_flux_measure",NULL )
+,		SchemaEntry("luminous_intensity_measure",NULL )
+,		SchemaEntry("magnetic_flux_density_measure",NULL )
+,		SchemaEntry("magnetic_flux_measure",NULL )
+,		SchemaEntry("marker_select",NULL )
+,		SchemaEntry("marker_type",NULL )
+,		SchemaEntry("mass_measure",NULL )
+,		SchemaEntry("measure_value",NULL )
+,		SchemaEntry("mechanical_design_and_draughting_relationship_select",NULL )
+,		SchemaEntry("mechanical_design_geometric_presentation_area_items",NULL )
+,		SchemaEntry("mechanical_design_geometric_presentation_representation_items",NULL )
+,		SchemaEntry("message",NULL )
+,		SchemaEntry("minute_in_hour",NULL )
+,		SchemaEntry("month_in_year_number",NULL )
+,		SchemaEntry("multi_language_attribute_item",NULL )
+,		SchemaEntry("name_attribute_select",NULL )
+,		SchemaEntry("name_item",NULL )
+,		SchemaEntry("non_negative_length_measure",NULL )
+,		SchemaEntry("nonnegative_integer",NULL )
+,		SchemaEntry("null_style",NULL )
+,		SchemaEntry("numeric_measure",NULL )
+,		SchemaEntry("organization_item",NULL )
+,		SchemaEntry("orientation_basis_select",NULL )
+,		SchemaEntry("parameter_value",NULL )
+,		SchemaEntry("pcurve_or_surface",NULL )
+,		SchemaEntry("person_and_organization_item",NULL )
+,		SchemaEntry("person_organization_select",NULL )
+,		SchemaEntry("picture_representation_item_select",NULL )
+,		SchemaEntry("plane_angle_measure",NULL )
+,		SchemaEntry("plane_or_planar_box",NULL )
+,		SchemaEntry("point_and_vector_member",NULL )
+,		SchemaEntry("point_and_vector_members",NULL )
+,		SchemaEntry("point_path_members",NULL )
+,		SchemaEntry("positive_integer",NULL )
+,		SchemaEntry("positive_length_measure",NULL )
+,		SchemaEntry("positive_plane_angle_measure",NULL )
+,		SchemaEntry("positive_ratio_measure",NULL )
+,		SchemaEntry("power_measure",NULL )
+,		SchemaEntry("preferred_surface_curve_representation",NULL )
+,		SchemaEntry("presentable_text",NULL )
+,		SchemaEntry("presentation_representation_select",NULL )
+,		SchemaEntry("presentation_size_assignment_select",NULL )
+,		SchemaEntry("presentation_style_select",NULL )
+,		SchemaEntry("presented_item_select",NULL )
+,		SchemaEntry("pressure_measure",NULL )
+,		SchemaEntry("product_definition_or_assembly_relationship",NULL )
+,		SchemaEntry("product_definition_or_breakdown_element_usage",NULL )
+,		SchemaEntry("product_definition_or_product_definition_relationship",NULL )
+,		SchemaEntry("product_or_formation_or_definition",NULL )
+,		SchemaEntry("project_item",NULL )
+,		SchemaEntry("radioactivity_measure",NULL )
+,		SchemaEntry("ratio_measure",NULL )
+,		SchemaEntry("rendering_properties_select",NULL )
+,		SchemaEntry("represented_definition",NULL )
+,		SchemaEntry("requirement_assigned_item",NULL )
+,		SchemaEntry("requirement_satisfaction_item",NULL )
+,		SchemaEntry("requirement_source_item",NULL )
+,		SchemaEntry("resistance_measure",NULL )
+,		SchemaEntry("reversible_topology",NULL )
+,		SchemaEntry("reversible_topology_item",NULL )
+,		SchemaEntry("role_select",NULL )
+,		SchemaEntry("rule_superseded_item",NULL )
+,		SchemaEntry("second_in_minute",NULL )
+,		SchemaEntry("security_classification_item",NULL )
+,		SchemaEntry("set_of_reversible_topology_item",NULL )
+,		SchemaEntry("set_representation_item",NULL )
+,		SchemaEntry("shading_curve_method",NULL )
+,		SchemaEntry("shading_surface_method",NULL )
+,		SchemaEntry("shape_definition",NULL )
+,		SchemaEntry("shell",NULL )
+,		SchemaEntry("si_prefix",NULL )
+,		SchemaEntry("si_unit_name",NULL )
+,		SchemaEntry("size_select",NULL )
+,		SchemaEntry("sketch_basis_select",NULL )
+,		SchemaEntry("solid_angle_measure",NULL )
+,		SchemaEntry("source",NULL )
+,		SchemaEntry("source_item",NULL )
+,		SchemaEntry("start_request_item",NULL )
+,		SchemaEntry("string_representation_item_select",NULL )
+,		SchemaEntry("style_context_select",NULL )
+,		SchemaEntry("surface_side",NULL )
+,		SchemaEntry("surface_side_style_select",NULL )
+,		SchemaEntry("surface_style_element_select",NULL )
+,		SchemaEntry("symbol_style_select",NULL )
+,		SchemaEntry("text",NULL )
+,		SchemaEntry("text_alignment",NULL )
+,		SchemaEntry("text_delineation",NULL )
+,		SchemaEntry("text_or_character",NULL )
+,		SchemaEntry("text_path",NULL )
+,		SchemaEntry("text_string_representation_item",NULL )
+,		SchemaEntry("thermodynamic_temperature_measure",NULL )
+,		SchemaEntry("time_interval_item",NULL )
+,		SchemaEntry("time_measure",NULL )
+,		SchemaEntry("tolerance_method_definition",NULL )
+,		SchemaEntry("transformation",NULL )
+,		SchemaEntry("transition_code",NULL )
+,		SchemaEntry("trim_condition_select",NULL )
+,		SchemaEntry("trim_intent",NULL )
+,		SchemaEntry("trimming_preference",NULL )
+,		SchemaEntry("trimming_select",NULL )
+,		SchemaEntry("u_direction_count",NULL )
+,		SchemaEntry("unit",NULL )
+,		SchemaEntry("v_direction_count",NULL )
+,		SchemaEntry("value_qualifier",NULL )
+,		SchemaEntry("vector_or_direction",NULL )
+,		SchemaEntry("velocity_measure",NULL )
+,		SchemaEntry("volume_measure",NULL )
+,		SchemaEntry("week_in_year_number",NULL )
+,		SchemaEntry("work_item",NULL )
+,		SchemaEntry("year_number",NULL )
+,		SchemaEntry("measure_with_unit",&STEP::ObjectHelper<measure_with_unit,2>::Construct )
+,		SchemaEntry("absorbed_dose_measure_with_unit",&STEP::ObjectHelper<absorbed_dose_measure_with_unit,0>::Construct )
+,		SchemaEntry("derived_unit",&STEP::ObjectHelper<derived_unit,1>::Construct )
+,		SchemaEntry("absorbed_dose_unit",&STEP::ObjectHelper<absorbed_dose_unit,0>::Construct )
+,		SchemaEntry("abstract_variable",&STEP::ObjectHelper<abstract_variable,0>::Construct )
+,		SchemaEntry("acceleration_measure_with_unit",&STEP::ObjectHelper<acceleration_measure_with_unit,0>::Construct )
+,		SchemaEntry("acceleration_unit",&STEP::ObjectHelper<acceleration_unit,0>::Construct )
+,		SchemaEntry("action",&STEP::ObjectHelper<action,3>::Construct )
+,		SchemaEntry("action_assignment",&STEP::ObjectHelper<action_assignment,1>::Construct )
+,		SchemaEntry("action_directive",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("action_method",&STEP::ObjectHelper<action_method,4>::Construct )
+,		SchemaEntry("action_method_assignment",&STEP::ObjectHelper<action_method_assignment,2>::Construct )
+,		SchemaEntry("action_method_relationship",&STEP::ObjectHelper<action_method_relationship,4>::Construct )
+,		SchemaEntry("action_method_role",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("action_property",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("action_property_representation",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("action_relationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("action_request_assignment",&STEP::ObjectHelper<action_request_assignment,1>::Construct )
+,		SchemaEntry("action_request_solution",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("action_request_status",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("action_status",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("address",&STEP::ObjectHelper<address,12>::Construct )
+,		SchemaEntry("representation",&STEP::ObjectHelper<representation,3>::Construct )
+,		SchemaEntry("shape_representation",&STEP::ObjectHelper<shape_representation,0>::Construct )
+,		SchemaEntry("advanced_brep_shape_representation",&STEP::ObjectHelper<advanced_brep_shape_representation,0>::Construct )
+,		SchemaEntry("face_surface",&STEP::ObjectHelper<face_surface,2>::Construct )
+,		SchemaEntry("advanced_face",&STEP::ObjectHelper<advanced_face,0>::Construct )
+,		SchemaEntry("alternate_product_relationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("amount_of_substance_measure_with_unit",&STEP::ObjectHelper<amount_of_substance_measure_with_unit,0>::Construct )
+,		SchemaEntry("named_unit",&STEP::ObjectHelper<named_unit,1>::Construct )
+,		SchemaEntry("amount_of_substance_unit",&STEP::ObjectHelper<amount_of_substance_unit,0>::Construct )
+,		SchemaEntry("angle_direction_reference",&STEP::ObjectHelper<angle_direction_reference,0>::Construct )
+,		SchemaEntry("representation_item",&STEP::ObjectHelper<representation_item,1>::Construct )
+,		SchemaEntry("geometric_representation_item",&STEP::ObjectHelper<geometric_representation_item,0>::Construct )
+,		SchemaEntry("draughting_callout",&STEP::ObjectHelper<draughting_callout,1>::Construct )
+,		SchemaEntry("dimension_curve_directed_callout",&STEP::ObjectHelper<dimension_curve_directed_callout,0>::Construct )
+,		SchemaEntry("angular_dimension",&STEP::ObjectHelper<angular_dimension,0>::Construct )
+,		SchemaEntry("shape_aspect_relationship",&STEP::ObjectHelper<shape_aspect_relationship,4>::Construct )
+,		SchemaEntry("dimensional_location",&STEP::ObjectHelper<dimensional_location,0>::Construct )
+,		SchemaEntry("angular_location",&STEP::ObjectHelper<angular_location,1>::Construct )
+,		SchemaEntry("dimensional_size",&STEP::ObjectHelper<dimensional_size,2>::Construct )
+,		SchemaEntry("angular_size",&STEP::ObjectHelper<angular_size,1>::Construct )
+,		SchemaEntry("geometric_tolerance",&STEP::ObjectHelper<geometric_tolerance,4>::Construct )
+,		SchemaEntry("geometric_tolerance_with_datum_reference",&STEP::ObjectHelper<geometric_tolerance_with_datum_reference,1>::Construct )
+,		SchemaEntry("angularity_tolerance",&STEP::ObjectHelper<angularity_tolerance,0>::Construct )
+,		SchemaEntry("styled_item",&STEP::ObjectHelper<styled_item,2>::Construct )
+,		SchemaEntry("annotation_occurrence",&STEP::ObjectHelper<annotation_occurrence,0>::Construct )
+,		SchemaEntry("annotation_curve_occurrence",&STEP::ObjectHelper<annotation_curve_occurrence,0>::Construct )
+,		SchemaEntry("annotation_fill_area",&STEP::ObjectHelper<annotation_fill_area,1>::Construct )
+,		SchemaEntry("annotation_fill_area_occurrence",&STEP::ObjectHelper<annotation_fill_area_occurrence,1>::Construct )
+,		SchemaEntry("annotation_occurrence_relationship",&STEP::ObjectHelper<annotation_occurrence_relationship,4>::Construct )
+,		SchemaEntry("annotation_occurrence_associativity",&STEP::ObjectHelper<annotation_occurrence_associativity,0>::Construct )
+,		SchemaEntry("annotation_plane",&STEP::ObjectHelper<annotation_plane,1>::Construct )
+,		SchemaEntry("annotation_symbol_occurrence",&STEP::ObjectHelper<annotation_symbol_occurrence,0>::Construct )
+,		SchemaEntry("annotation_subfigure_occurrence",&STEP::ObjectHelper<annotation_subfigure_occurrence,0>::Construct )
+,		SchemaEntry("mapped_item",&STEP::ObjectHelper<mapped_item,2>::Construct )
+,		SchemaEntry("annotation_symbol",&STEP::ObjectHelper<annotation_symbol,0>::Construct )
+,		SchemaEntry("annotation_text",&STEP::ObjectHelper<annotation_text,0>::Construct )
+,		SchemaEntry("annotation_text_character",&STEP::ObjectHelper<annotation_text_character,1>::Construct )
+,		SchemaEntry("annotation_text_occurrence",&STEP::ObjectHelper<annotation_text_occurrence,0>::Construct )
+,		SchemaEntry("shape_aspect",&STEP::ObjectHelper<shape_aspect,4>::Construct )
+,		SchemaEntry("derived_shape_aspect",&STEP::ObjectHelper<derived_shape_aspect,0>::Construct )
+,		SchemaEntry("apex",&STEP::ObjectHelper<apex,0>::Construct )
+,		SchemaEntry("application_context",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("application_context_element",&STEP::ObjectHelper<application_context_element,2>::Construct )
+,		SchemaEntry("application_protocol_definition",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("applied_action_assignment",&STEP::ObjectHelper<applied_action_assignment,1>::Construct )
+,		SchemaEntry("applied_action_method_assignment",&STEP::ObjectHelper<applied_action_method_assignment,1>::Construct )
+,		SchemaEntry("applied_action_request_assignment",&STEP::ObjectHelper<applied_action_request_assignment,1>::Construct )
+,		SchemaEntry("approval_assignment",&STEP::ObjectHelper<approval_assignment,1>::Construct )
+,		SchemaEntry("applied_approval_assignment",&STEP::ObjectHelper<applied_approval_assignment,1>::Construct )
+,		SchemaEntry("attribute_classification_assignment",&STEP::ObjectHelper<attribute_classification_assignment,3>::Construct )
+,		SchemaEntry("applied_attribute_classification_assignment",&STEP::ObjectHelper<applied_attribute_classification_assignment,1>::Construct )
+,		SchemaEntry("certification_assignment",&STEP::ObjectHelper<certification_assignment,1>::Construct )
+,		SchemaEntry("applied_certification_assignment",&STEP::ObjectHelper<applied_certification_assignment,1>::Construct )
+,		SchemaEntry("classification_assignment",&STEP::ObjectHelper<classification_assignment,2>::Construct )
+,		SchemaEntry("applied_classification_assignment",&STEP::ObjectHelper<applied_classification_assignment,1>::Construct )
+,		SchemaEntry("contract_assignment",&STEP::ObjectHelper<contract_assignment,1>::Construct )
+,		SchemaEntry("applied_contract_assignment",&STEP::ObjectHelper<applied_contract_assignment,1>::Construct )
+,		SchemaEntry("date_and_time_assignment",&STEP::ObjectHelper<date_and_time_assignment,2>::Construct )
+,		SchemaEntry("applied_date_and_time_assignment",&STEP::ObjectHelper<applied_date_and_time_assignment,1>::Construct )
+,		SchemaEntry("date_assignment",&STEP::ObjectHelper<date_assignment,2>::Construct )
+,		SchemaEntry("applied_date_assignment",&STEP::ObjectHelper<applied_date_assignment,1>::Construct )
+,		SchemaEntry("document_reference",&STEP::ObjectHelper<document_reference,2>::Construct )
+,		SchemaEntry("applied_document_reference",&STEP::ObjectHelper<applied_document_reference,1>::Construct )
+,		SchemaEntry("document_usage_constraint_assignment",&STEP::ObjectHelper<document_usage_constraint_assignment,2>::Construct )
+,		SchemaEntry("applied_document_usage_constraint_assignment",&STEP::ObjectHelper<applied_document_usage_constraint_assignment,1>::Construct )
+,		SchemaEntry("effectivity_assignment",&STEP::ObjectHelper<effectivity_assignment,1>::Construct )
+,		SchemaEntry("applied_effectivity_assignment",&STEP::ObjectHelper<applied_effectivity_assignment,1>::Construct )
+,		SchemaEntry("event_occurrence_assignment",&STEP::ObjectHelper<event_occurrence_assignment,2>::Construct )
+,		SchemaEntry("applied_event_occurrence_assignment",&STEP::ObjectHelper<applied_event_occurrence_assignment,1>::Construct )
+,		SchemaEntry("identification_assignment",&STEP::ObjectHelper<identification_assignment,2>::Construct )
+,		SchemaEntry("external_identification_assignment",&STEP::ObjectHelper<external_identification_assignment,1>::Construct )
+,		SchemaEntry("applied_external_identification_assignment",&STEP::ObjectHelper<applied_external_identification_assignment,1>::Construct )
+,		SchemaEntry("group_assignment",&STEP::ObjectHelper<group_assignment,1>::Construct )
+,		SchemaEntry("applied_group_assignment",&STEP::ObjectHelper<applied_group_assignment,1>::Construct )
+,		SchemaEntry("applied_identification_assignment",&STEP::ObjectHelper<applied_identification_assignment,1>::Construct )
+,		SchemaEntry("name_assignment",&STEP::ObjectHelper<name_assignment,1>::Construct )
+,		SchemaEntry("applied_name_assignment",&STEP::ObjectHelper<applied_name_assignment,1>::Construct )
+,		SchemaEntry("organization_assignment",&STEP::ObjectHelper<organization_assignment,2>::Construct )
+,		SchemaEntry("applied_organization_assignment",&STEP::ObjectHelper<applied_organization_assignment,1>::Construct )
+,		SchemaEntry("organizational_project_assignment",&STEP::ObjectHelper<organizational_project_assignment,2>::Construct )
+,		SchemaEntry("applied_organizational_project_assignment",&STEP::ObjectHelper<applied_organizational_project_assignment,1>::Construct )
+,		SchemaEntry("person_and_organization_assignment",&STEP::ObjectHelper<person_and_organization_assignment,2>::Construct )
+,		SchemaEntry("applied_person_and_organization_assignment",&STEP::ObjectHelper<applied_person_and_organization_assignment,1>::Construct )
+,		SchemaEntry("presented_item",&STEP::ObjectHelper<presented_item,0>::Construct )
+,		SchemaEntry("applied_presented_item",&STEP::ObjectHelper<applied_presented_item,1>::Construct )
+,		SchemaEntry("security_classification_assignment",&STEP::ObjectHelper<security_classification_assignment,1>::Construct )
+,		SchemaEntry("applied_security_classification_assignment",&STEP::ObjectHelper<applied_security_classification_assignment,1>::Construct )
+,		SchemaEntry("time_interval_assignment",&STEP::ObjectHelper<time_interval_assignment,2>::Construct )
+,		SchemaEntry("applied_time_interval_assignment",&STEP::ObjectHelper<applied_time_interval_assignment,1>::Construct )
+,		SchemaEntry("applied_usage_right",&STEP::ObjectHelper<applied_usage_right,0>::Construct )
+,		SchemaEntry("approval",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("approval_date_time",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("approval_person_organization",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("approval_relationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("approval_role",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("approval_status",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("area_in_set",&STEP::ObjectHelper<area_in_set,2>::Construct )
+,		SchemaEntry("area_measure_with_unit",&STEP::ObjectHelper<area_measure_with_unit,0>::Construct )
+,		SchemaEntry("area_unit",&STEP::ObjectHelper<area_unit,0>::Construct )
+,		SchemaEntry("product_definition_relationship",&STEP::ObjectHelper<product_definition_relationship,5>::Construct )
+,		SchemaEntry("product_definition_usage",&STEP::ObjectHelper<product_definition_usage,0>::Construct )
+,		SchemaEntry("assembly_component_usage",&STEP::ObjectHelper<assembly_component_usage,1>::Construct )
+,		SchemaEntry("assembly_component_usage_substitute",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("assigned_requirement",&STEP::ObjectHelper<assigned_requirement,1>::Construct )
+,		SchemaEntry("compound_representation_item",&STEP::ObjectHelper<compound_representation_item,1>::Construct )
+,		SchemaEntry("atomic_formula",&STEP::ObjectHelper<atomic_formula,0>::Construct )
+,		SchemaEntry("attribute_assertion",&STEP::ObjectHelper<attribute_assertion,0>::Construct )
+,		SchemaEntry("attribute_language_assignment",&STEP::ObjectHelper<attribute_language_assignment,1>::Construct )
+,		SchemaEntry("attribute_value_assignment",&STEP::ObjectHelper<attribute_value_assignment,3>::Construct )
+,		SchemaEntry("attribute_value_role",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("auxiliary_geometric_representation_item",&STEP::ObjectHelper<auxiliary_geometric_representation_item,0>::Construct )
+,		SchemaEntry("placement",&STEP::ObjectHelper<placement,1>::Construct )
+,		SchemaEntry("axis1_placement",&STEP::ObjectHelper<axis1_placement,1>::Construct )
+,		SchemaEntry("axis2_placement_2d",&STEP::ObjectHelper<axis2_placement_2d,1>::Construct )
+,		SchemaEntry("axis2_placement_3d",&STEP::ObjectHelper<axis2_placement_3d,2>::Construct )
+,		SchemaEntry("curve",&STEP::ObjectHelper<curve,0>::Construct )
+,		SchemaEntry("bounded_curve",&STEP::ObjectHelper<bounded_curve,0>::Construct )
+,		SchemaEntry("b_spline_curve",&STEP::ObjectHelper<b_spline_curve,5>::Construct )
+,		SchemaEntry("b_spline_curve_with_knots",&STEP::ObjectHelper<b_spline_curve_with_knots,3>::Construct )
+,		SchemaEntry("surface",&STEP::ObjectHelper<surface,0>::Construct )
+,		SchemaEntry("bounded_surface",&STEP::ObjectHelper<bounded_surface,0>::Construct )
+,		SchemaEntry("b_spline_surface",&STEP::ObjectHelper<b_spline_surface,6>::Construct )
+,		SchemaEntry("b_spline_surface_with_knots",&STEP::ObjectHelper<b_spline_surface_with_knots,5>::Construct )
+,		SchemaEntry("product_definition",&STEP::ObjectHelper<product_definition,4>::Construct )
+,		SchemaEntry("rule_software_definition",&STEP::ObjectHelper<rule_software_definition,0>::Construct )
+,		SchemaEntry("rule_definition",&STEP::ObjectHelper<rule_definition,0>::Construct )
+,		SchemaEntry("back_chaining_rule",&STEP::ObjectHelper<back_chaining_rule,0>::Construct )
+,		SchemaEntry("back_chaining_rule_body",&STEP::ObjectHelper<back_chaining_rule_body,0>::Construct )
+,		SchemaEntry("colour",&STEP::ObjectHelper<colour,0>::Construct )
+,		SchemaEntry("background_colour",&STEP::ObjectHelper<background_colour,1>::Construct )
+,		SchemaEntry("beveled_sheet_representation",&STEP::ObjectHelper<beveled_sheet_representation,0>::Construct )
+,		SchemaEntry("bezier_curve",&STEP::ObjectHelper<bezier_curve,0>::Construct )
+,		SchemaEntry("bezier_surface",&STEP::ObjectHelper<bezier_surface,0>::Construct )
+,		SchemaEntry("generic_expression",&STEP::ObjectHelper<generic_expression,0>::Construct )
+,		SchemaEntry("binary_generic_expression",&STEP::ObjectHelper<binary_generic_expression,1>::Construct )
+,		SchemaEntry("binary_numeric_expression",&STEP::ObjectHelper<binary_numeric_expression,0>::Construct )
+,		SchemaEntry("binary_representation_item",&STEP::ObjectHelper<binary_representation_item,1>::Construct )
+,		SchemaEntry("block",&STEP::ObjectHelper<block,4>::Construct )
+,		SchemaEntry("expression",&STEP::ObjectHelper<expression,0>::Construct )
+,		SchemaEntry("boolean_expression",&STEP::ObjectHelper<boolean_expression,0>::Construct )
+,		SchemaEntry("boolean_literal",&STEP::ObjectHelper<boolean_literal,1>::Construct )
+,		SchemaEntry("boolean_representation_item",&STEP::ObjectHelper<boolean_representation_item,0>::Construct )
+,		SchemaEntry("boolean_result",&STEP::ObjectHelper<boolean_result,3>::Construct )
+,		SchemaEntry("composite_curve",&STEP::ObjectHelper<composite_curve,2>::Construct )
+,		SchemaEntry("composite_curve_on_surface",&STEP::ObjectHelper<composite_curve_on_surface,0>::Construct )
+,		SchemaEntry("boundary_curve",&STEP::ObjectHelper<boundary_curve,0>::Construct )
+,		SchemaEntry("bounded_pcurve",&STEP::ObjectHelper<bounded_pcurve,0>::Construct )
+,		SchemaEntry("bounded_surface_curve",&STEP::ObjectHelper<bounded_surface_curve,0>::Construct )
+,		SchemaEntry("founded_item",&STEP::ObjectHelper<founded_item,0>::Construct )
+,		SchemaEntry("box_domain",&STEP::ObjectHelper<box_domain,4>::Construct )
+,		SchemaEntry("half_space_solid",&STEP::ObjectHelper<half_space_solid,2>::Construct )
+,		SchemaEntry("boxed_half_space",&STEP::ObjectHelper<boxed_half_space,1>::Construct )
+,		SchemaEntry("breakdown_context",&STEP::ObjectHelper<breakdown_context,0>::Construct )
+,		SchemaEntry("breakdown_element_group_assignment",&STEP::ObjectHelper<breakdown_element_group_assignment,1>::Construct )
+,		SchemaEntry("breakdown_element_realization",&STEP::ObjectHelper<breakdown_element_realization,0>::Construct )
+,		SchemaEntry("breakdown_element_usage",&STEP::ObjectHelper<breakdown_element_usage,0>::Construct )
+,		SchemaEntry("breakdown_of",&STEP::ObjectHelper<breakdown_of,0>::Construct )
+,		SchemaEntry("solid_model",&STEP::ObjectHelper<solid_model,0>::Construct )
+,		SchemaEntry("manifold_solid_brep",&STEP::ObjectHelper<manifold_solid_brep,1>::Construct )
+,		SchemaEntry("brep_with_voids",&STEP::ObjectHelper<brep_with_voids,1>::Construct )
+,		SchemaEntry("bytes_representation_item",&STEP::ObjectHelper<bytes_representation_item,0>::Construct )
+,		SchemaEntry("date",&STEP::ObjectHelper<date,1>::Construct )
+,		SchemaEntry("calendar_date",&STEP::ObjectHelper<calendar_date,2>::Construct )
+,		SchemaEntry("camera_image",&STEP::ObjectHelper<camera_image,0>::Construct )
+,		SchemaEntry("camera_image_3d_with_scale",&STEP::ObjectHelper<camera_image_3d_with_scale,0>::Construct )
+,		SchemaEntry("camera_model",&STEP::ObjectHelper<camera_model,0>::Construct )
+,		SchemaEntry("camera_model_d3",&STEP::ObjectHelper<camera_model_d3,2>::Construct )
+,		SchemaEntry("camera_model_d3_multi_clipping",&STEP::ObjectHelper<camera_model_d3_multi_clipping,1>::Construct )
+,		SchemaEntry("camera_model_d3_multi_clipping_intersection",&STEP::ObjectHelper<camera_model_d3_multi_clipping_intersection,1>::Construct )
+,		SchemaEntry("camera_model_d3_multi_clipping_union",&STEP::ObjectHelper<camera_model_d3_multi_clipping_union,1>::Construct )
+,		SchemaEntry("camera_model_d3_with_hlhsr",&STEP::ObjectHelper<camera_model_d3_with_hlhsr,1>::Construct )
+,		SchemaEntry("camera_model_with_light_sources",&STEP::ObjectHelper<camera_model_with_light_sources,1>::Construct )
+,		SchemaEntry("representation_map",&STEP::ObjectHelper<representation_map,2>::Construct )
+,		SchemaEntry("camera_usage",&STEP::ObjectHelper<camera_usage,0>::Construct )
+,		SchemaEntry("capacitance_measure_with_unit",&STEP::ObjectHelper<capacitance_measure_with_unit,0>::Construct )
+,		SchemaEntry("capacitance_unit",&STEP::ObjectHelper<capacitance_unit,0>::Construct )
+,		SchemaEntry("point",&STEP::ObjectHelper<point,0>::Construct )
+,		SchemaEntry("cartesian_point",&STEP::ObjectHelper<cartesian_point,1>::Construct )
+,		SchemaEntry("cartesian_transformation_operator",&STEP::ObjectHelper<cartesian_transformation_operator,4>::Construct )
+,		SchemaEntry("cartesian_transformation_operator_2d",&STEP::ObjectHelper<cartesian_transformation_operator_2d,0>::Construct )
+,		SchemaEntry("cartesian_transformation_operator_3d",&STEP::ObjectHelper<cartesian_transformation_operator_3d,1>::Construct )
+,		SchemaEntry("cc_design_approval",&STEP::ObjectHelper<cc_design_approval,1>::Construct )
+,		SchemaEntry("cc_design_certification",&STEP::ObjectHelper<cc_design_certification,1>::Construct )
+,		SchemaEntry("cc_design_contract",&STEP::ObjectHelper<cc_design_contract,1>::Construct )
+,		SchemaEntry("cc_design_date_and_time_assignment",&STEP::ObjectHelper<cc_design_date_and_time_assignment,1>::Construct )
+,		SchemaEntry("cc_design_person_and_organization_assignment",&STEP::ObjectHelper<cc_design_person_and_organization_assignment,1>::Construct )
+,		SchemaEntry("cc_design_security_classification",&STEP::ObjectHelper<cc_design_security_classification,1>::Construct )
+,		SchemaEntry("cc_design_specification_reference",&STEP::ObjectHelper<cc_design_specification_reference,1>::Construct )
+,		SchemaEntry("celsius_temperature_measure_with_unit",&STEP::ObjectHelper<celsius_temperature_measure_with_unit,0>::Construct )
+,		SchemaEntry("centre_of_symmetry",&STEP::ObjectHelper<centre_of_symmetry,0>::Construct )
+,		SchemaEntry("certification",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("certification_type",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("change",&STEP::ObjectHelper<change,1>::Construct )
+,		SchemaEntry("change_request",&STEP::ObjectHelper<change_request,1>::Construct )
+,		SchemaEntry("character_glyph_font_usage",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("character_glyph_style_outline",&STEP::ObjectHelper<character_glyph_style_outline,1>::Construct )
+,		SchemaEntry("character_glyph_style_stroke",&STEP::ObjectHelper<character_glyph_style_stroke,1>::Construct )
+,		SchemaEntry("symbol_representation",&STEP::ObjectHelper<symbol_representation,0>::Construct )
+,		SchemaEntry("generic_character_glyph_symbol",&STEP::ObjectHelper<generic_character_glyph_symbol,0>::Construct )
+,		SchemaEntry("character_glyph_symbol",&STEP::ObjectHelper<character_glyph_symbol,2>::Construct )
+,		SchemaEntry("character_glyph_symbol_outline",&STEP::ObjectHelper<character_glyph_symbol_outline,1>::Construct )
+,		SchemaEntry("character_glyph_symbol_stroke",&STEP::ObjectHelper<character_glyph_symbol_stroke,1>::Construct )
+,		SchemaEntry("general_property",&STEP::ObjectHelper<general_property,3>::Construct )
+,		SchemaEntry("characteristic_data_column_header",&STEP::ObjectHelper<characteristic_data_column_header,0>::Construct )
+,		SchemaEntry("general_property_relationship",&STEP::ObjectHelper<general_property_relationship,4>::Construct )
+,		SchemaEntry("characteristic_data_column_header_link",&STEP::ObjectHelper<characteristic_data_column_header_link,0>::Construct )
+,		SchemaEntry("characteristic_data_table_header",&STEP::ObjectHelper<characteristic_data_table_header,0>::Construct )
+,		SchemaEntry("characteristic_data_table_header_decomposition",&STEP::ObjectHelper<characteristic_data_table_header_decomposition,0>::Construct )
+,		SchemaEntry("group",&STEP::ObjectHelper<group,2>::Construct )
+,		SchemaEntry("characteristic_type",&STEP::ObjectHelper<characteristic_type,0>::Construct )
+,		SchemaEntry("characterized_class",&STEP::ObjectHelper<characterized_class,0>::Construct )
+,		SchemaEntry("characterized_object",&STEP::ObjectHelper<characterized_object,2>::Construct )
+,		SchemaEntry("conic",&STEP::ObjectHelper<conic,1>::Construct )
+,		SchemaEntry("circle",&STEP::ObjectHelper<circle,1>::Construct )
+,		SchemaEntry("circular_runout_tolerance",&STEP::ObjectHelper<circular_runout_tolerance,0>::Construct )
+,		SchemaEntry("class_t",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("class_by_extension",&STEP::ObjectHelper<class_by_extension,0>::Construct )
+,		SchemaEntry("class_by_intension",&STEP::ObjectHelper<class_by_intension,0>::Construct )
+,		SchemaEntry("class_system",&STEP::ObjectHelper<class_system,0>::Construct )
+,		SchemaEntry("effectivity_context_assignment",&STEP::ObjectHelper<effectivity_context_assignment,2>::Construct )
+,		SchemaEntry("class_usage_effectivity_context_assignment",&STEP::ObjectHelper<class_usage_effectivity_context_assignment,1>::Construct )
+,		SchemaEntry("classification_role",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("topological_representation_item",&STEP::ObjectHelper<topological_representation_item,0>::Construct )
+,		SchemaEntry("connected_face_set",&STEP::ObjectHelper<connected_face_set,1>::Construct )
+,		SchemaEntry("closed_shell",&STEP::ObjectHelper<closed_shell,0>::Construct )
+,		SchemaEntry("coaxiality_tolerance",&STEP::ObjectHelper<coaxiality_tolerance,0>::Construct )
+,		SchemaEntry("colour_specification",&STEP::ObjectHelper<colour_specification,1>::Construct )
+,		SchemaEntry("colour_rgb",&STEP::ObjectHelper<colour_rgb,3>::Construct )
+,		SchemaEntry("common_datum",&STEP::ObjectHelper<common_datum,0>::Construct )
+,		SchemaEntry("comparison_expression",&STEP::ObjectHelper<comparison_expression,0>::Construct )
+,		SchemaEntry("complex_clause",&STEP::ObjectHelper<complex_clause,0>::Construct )
+,		SchemaEntry("complex_conjunctive_clause",&STEP::ObjectHelper<complex_conjunctive_clause,0>::Construct )
+,		SchemaEntry("complex_disjunctive_clause",&STEP::ObjectHelper<complex_disjunctive_clause,0>::Construct )
+,		SchemaEntry("modified_solid",&STEP::ObjectHelper<modified_solid,2>::Construct )
+,		SchemaEntry("shelled_solid",&STEP::ObjectHelper<shelled_solid,2>::Construct )
+,		SchemaEntry("complex_shelled_solid",&STEP::ObjectHelper<complex_shelled_solid,1>::Construct )
+,		SchemaEntry("composite_assembly_definition",&STEP::ObjectHelper<composite_assembly_definition,0>::Construct )
+,		SchemaEntry("composite_assembly_sequence_definition",&STEP::ObjectHelper<composite_assembly_sequence_definition,0>::Construct )
+,		SchemaEntry("laminate_table",&STEP::ObjectHelper<laminate_table,0>::Construct )
+,		SchemaEntry("part_laminate_table",&STEP::ObjectHelper<part_laminate_table,0>::Construct )
+,		SchemaEntry("composite_assembly_table",&STEP::ObjectHelper<composite_assembly_table,0>::Construct )
+,		SchemaEntry("composite_curve_segment",&STEP::ObjectHelper<composite_curve_segment,3>::Construct )
+,		SchemaEntry("material_designation",&STEP::ObjectHelper<material_designation,2>::Construct )
+,		SchemaEntry("composite_material_designation",&STEP::ObjectHelper<composite_material_designation,0>::Construct )
+,		SchemaEntry("composite_shape_aspect",&STEP::ObjectHelper<composite_shape_aspect,0>::Construct )
+,		SchemaEntry("composite_sheet_representation",&STEP::ObjectHelper<composite_sheet_representation,0>::Construct )
+,		SchemaEntry("composite_text",&STEP::ObjectHelper<composite_text,1>::Construct )
+,		SchemaEntry("composite_text_with_associated_curves",&STEP::ObjectHelper<composite_text_with_associated_curves,1>::Construct )
+,		SchemaEntry("composite_text_with_blanking_box",&STEP::ObjectHelper<composite_text_with_blanking_box,1>::Construct )
+,		SchemaEntry("composite_text_with_delineation",&STEP::ObjectHelper<composite_text_with_delineation,1>::Construct )
+,		SchemaEntry("composite_text_with_extent",&STEP::ObjectHelper<composite_text_with_extent,1>::Construct )
+,		SchemaEntry("compound_shape_representation",&STEP::ObjectHelper<compound_shape_representation,0>::Construct )
+,		SchemaEntry("concentricity_tolerance",&STEP::ObjectHelper<concentricity_tolerance,0>::Construct )
+,		SchemaEntry("concept_feature_operator",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("concept_feature_relationship",&STEP::ObjectHelper<concept_feature_relationship,4>::Construct )
+,		SchemaEntry("concept_feature_relationship_with_condition",&STEP::ObjectHelper<concept_feature_relationship_with_condition,1>::Construct )
+,		SchemaEntry("product_concept_feature",&STEP::ObjectHelper<product_concept_feature,3>::Construct )
+,		SchemaEntry("conditional_concept_feature",&STEP::ObjectHelper<conditional_concept_feature,1>::Construct )
+,		SchemaEntry("conductance_measure_with_unit",&STEP::ObjectHelper<conductance_measure_with_unit,0>::Construct )
+,		SchemaEntry("conductance_unit",&STEP::ObjectHelper<conductance_unit,0>::Construct )
+,		SchemaEntry("configuration_item",&STEP::ObjectHelper<configuration_item,5>::Construct )
+,		SchemaEntry("configurable_item",&STEP::ObjectHelper<configurable_item,1>::Construct )
+,		SchemaEntry("configuration_design",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("effectivity",&STEP::ObjectHelper<effectivity,1>::Construct )
+,		SchemaEntry("product_definition_effectivity",&STEP::ObjectHelper<product_definition_effectivity,1>::Construct )
+,		SchemaEntry("configuration_effectivity",&STEP::ObjectHelper<configuration_effectivity,1>::Construct )
+,		SchemaEntry("configuration_item_relationship",&STEP::ObjectHelper<configuration_item_relationship,4>::Construct )
+,		SchemaEntry("configuration_item_hierarchical_relationship",&STEP::ObjectHelper<configuration_item_hierarchical_relationship,0>::Construct )
+,		SchemaEntry("configuration_item_revision_sequence",&STEP::ObjectHelper<configuration_item_revision_sequence,0>::Construct )
+,		SchemaEntry("configured_effectivity_assignment",&STEP::ObjectHelper<configured_effectivity_assignment,1>::Construct )
+,		SchemaEntry("configured_effectivity_context_assignment",&STEP::ObjectHelper<configured_effectivity_context_assignment,1>::Construct )
+,		SchemaEntry("conical_stepped_hole_transition",&STEP::ObjectHelper<conical_stepped_hole_transition,3>::Construct )
+,		SchemaEntry("elementary_surface",&STEP::ObjectHelper<elementary_surface,1>::Construct )
+,		SchemaEntry("conical_surface",&STEP::ObjectHelper<conical_surface,2>::Construct )
+,		SchemaEntry("connected_edge_set",&STEP::ObjectHelper<connected_edge_set,1>::Construct )
+,		SchemaEntry("connected_face_sub_set",&STEP::ObjectHelper<connected_face_sub_set,1>::Construct )
+,		SchemaEntry("constructive_geometry_representation",&STEP::ObjectHelper<constructive_geometry_representation,0>::Construct )
+,		SchemaEntry("representation_relationship",&STEP::ObjectHelper<representation_relationship,4>::Construct )
+,		SchemaEntry("constructive_geometry_representation_relationship",&STEP::ObjectHelper<constructive_geometry_representation_relationship,0>::Construct )
+,		SchemaEntry("contact_ratio_representation",&STEP::ObjectHelper<contact_ratio_representation,0>::Construct )
+,		SchemaEntry("invisibility",&STEP::ObjectHelper<invisibility,1>::Construct )
+,		SchemaEntry("context_dependent_invisibility",&STEP::ObjectHelper<context_dependent_invisibility,1>::Construct )
+,		SchemaEntry("over_riding_styled_item",&STEP::ObjectHelper<over_riding_styled_item,1>::Construct )
+,		SchemaEntry("context_dependent_over_riding_styled_item",&STEP::ObjectHelper<context_dependent_over_riding_styled_item,1>::Construct )
+,		SchemaEntry("context_dependent_shape_representation",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("context_dependent_unit",&STEP::ObjectHelper<context_dependent_unit,1>::Construct )
+,		SchemaEntry("contract",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("contract_relationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("contract_type",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("conversion_based_unit",&STEP::ObjectHelper<conversion_based_unit,2>::Construct )
+,		SchemaEntry("coordinated_universal_time_offset",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("csg_shape_representation",&STEP::ObjectHelper<csg_shape_representation,0>::Construct )
+,		SchemaEntry("csg_solid",&STEP::ObjectHelper<csg_solid,1>::Construct )
+,		SchemaEntry("currency",&STEP::ObjectHelper<currency,0>::Construct )
+,		SchemaEntry("currency_measure_with_unit",&STEP::ObjectHelper<currency_measure_with_unit,0>::Construct )
+,		SchemaEntry("curve_bounded_surface",&STEP::ObjectHelper<curve_bounded_surface,3>::Construct )
+,		SchemaEntry("curve_dimension",&STEP::ObjectHelper<curve_dimension,0>::Construct )
+,		SchemaEntry("curve_replica",&STEP::ObjectHelper<curve_replica,2>::Construct )
+,		SchemaEntry("curve_style",&STEP::ObjectHelper<curve_style,4>::Construct )
+,		SchemaEntry("curve_style_font",&STEP::ObjectHelper<curve_style_font,2>::Construct )
+,		SchemaEntry("curve_style_font_and_scaling",&STEP::ObjectHelper<curve_style_font_and_scaling,3>::Construct )
+,		SchemaEntry("curve_style_font_pattern",&STEP::ObjectHelper<curve_style_font_pattern,2>::Construct )
+,		SchemaEntry("curve_style_rendering",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("curve_swept_solid_shape_representation",&STEP::ObjectHelper<curve_swept_solid_shape_representation,0>::Construct )
+,		SchemaEntry("cylindrical_surface",&STEP::ObjectHelper<cylindrical_surface,1>::Construct )
+,		SchemaEntry("cylindricity_tolerance",&STEP::ObjectHelper<cylindricity_tolerance,0>::Construct )
+,		SchemaEntry("data_environment",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("date_and_time",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("date_representation_item",&STEP::ObjectHelper<date_representation_item,0>::Construct )
+,		SchemaEntry("date_role",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("date_time_representation_item",&STEP::ObjectHelper<date_time_representation_item,0>::Construct )
+,		SchemaEntry("date_time_role",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("dated_effectivity",&STEP::ObjectHelper<dated_effectivity,2>::Construct )
+,		SchemaEntry("datum",&STEP::ObjectHelper<datum,1>::Construct )
+,		SchemaEntry("datum_feature",&STEP::ObjectHelper<datum_feature,0>::Construct )
+,		SchemaEntry("datum_feature_callout",&STEP::ObjectHelper<datum_feature_callout,0>::Construct )
+,		SchemaEntry("datum_reference",&STEP::ObjectHelper<datum_reference,2>::Construct )
+,		SchemaEntry("datum_target",&STEP::ObjectHelper<datum_target,1>::Construct )
+,		SchemaEntry("datum_target_callout",&STEP::ObjectHelper<datum_target_callout,0>::Construct )
+,		SchemaEntry("default_tolerance_table",&STEP::ObjectHelper<default_tolerance_table,0>::Construct )
+,		SchemaEntry("default_tolerance_table_cell",&STEP::ObjectHelper<default_tolerance_table_cell,0>::Construct )
+,		SchemaEntry("defined_symbol",&STEP::ObjectHelper<defined_symbol,2>::Construct )
+,		SchemaEntry("definitional_representation",&STEP::ObjectHelper<definitional_representation,0>::Construct )
+,		SchemaEntry("definitional_representation_relationship",&STEP::ObjectHelper<definitional_representation_relationship,0>::Construct )
+,		SchemaEntry("definitional_representation_relationship_with_same_context",&STEP::ObjectHelper<definitional_representation_relationship_with_same_context,0>::Construct )
+,		SchemaEntry("degenerate_pcurve",&STEP::ObjectHelper<degenerate_pcurve,2>::Construct )
+,		SchemaEntry("toroidal_surface",&STEP::ObjectHelper<toroidal_surface,2>::Construct )
+,		SchemaEntry("degenerate_toroidal_surface",&STEP::ObjectHelper<degenerate_toroidal_surface,1>::Construct )
+,		SchemaEntry("derived_unit_element",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("description_attribute",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("descriptive_representation_item",&STEP::ObjectHelper<descriptive_representation_item,1>::Construct )
+,		SchemaEntry("product_definition_context",&STEP::ObjectHelper<product_definition_context,1>::Construct )
+,		SchemaEntry("design_context",&STEP::ObjectHelper<design_context,0>::Construct )
+,		SchemaEntry("design_make_from_relationship",&STEP::ObjectHelper<design_make_from_relationship,0>::Construct )
+,		SchemaEntry("diameter_dimension",&STEP::ObjectHelper<diameter_dimension,0>::Construct )
+,		SchemaEntry("ratio_measure_with_unit",&STEP::ObjectHelper<ratio_measure_with_unit,0>::Construct )
+,		SchemaEntry("dielectric_constant_measure_with_unit",&STEP::ObjectHelper<dielectric_constant_measure_with_unit,0>::Construct )
+,		SchemaEntry("dimension_callout",&STEP::ObjectHelper<dimension_callout,0>::Construct )
+,		SchemaEntry("draughting_callout_relationship",&STEP::ObjectHelper<draughting_callout_relationship,4>::Construct )
+,		SchemaEntry("dimension_callout_component_relationship",&STEP::ObjectHelper<dimension_callout_component_relationship,0>::Construct )
+,		SchemaEntry("dimension_callout_relationship",&STEP::ObjectHelper<dimension_callout_relationship,0>::Construct )
+,		SchemaEntry("dimension_curve",&STEP::ObjectHelper<dimension_curve,0>::Construct )
+,		SchemaEntry("terminator_symbol",&STEP::ObjectHelper<terminator_symbol,1>::Construct )
+,		SchemaEntry("dimension_curve_terminator",&STEP::ObjectHelper<dimension_curve_terminator,1>::Construct )
+,		SchemaEntry("dimension_curve_terminator_to_projection_curve_associativity",&STEP::ObjectHelper<dimension_curve_terminator_to_projection_curve_associativity,0>::Construct )
+,		SchemaEntry("dimension_pair",&STEP::ObjectHelper<dimension_pair,0>::Construct )
+,		SchemaEntry("dimension_related_tolerance_zone_element",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("dimension_text_associativity",&STEP::ObjectHelper<dimension_text_associativity,0>::Construct )
+,		SchemaEntry("dimensional_characteristic_representation",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("dimensional_exponents",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("dimensional_location_with_path",&STEP::ObjectHelper<dimensional_location_with_path,1>::Construct )
+,		SchemaEntry("dimensional_size_with_path",&STEP::ObjectHelper<dimensional_size_with_path,1>::Construct )
+,		SchemaEntry("executed_action",&STEP::ObjectHelper<executed_action,0>::Construct )
+,		SchemaEntry("directed_action",&STEP::ObjectHelper<directed_action,1>::Construct )
+,		SchemaEntry("directed_dimensional_location",&STEP::ObjectHelper<directed_dimensional_location,0>::Construct )
+,		SchemaEntry("direction",&STEP::ObjectHelper<direction,1>::Construct )
+,		SchemaEntry("document",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("document_file",&STEP::ObjectHelper<document_file,0>::Construct )
+,		SchemaEntry("document_identifier",&STEP::ObjectHelper<document_identifier,0>::Construct )
+,		SchemaEntry("document_identifier_assignment",&STEP::ObjectHelper<document_identifier_assignment,1>::Construct )
+,		SchemaEntry("document_product_association",&STEP::ObjectHelper<document_product_association,4>::Construct )
+,		SchemaEntry("document_product_equivalence",&STEP::ObjectHelper<document_product_equivalence,0>::Construct )
+,		SchemaEntry("document_relationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("document_representation_type",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("document_type",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("document_usage_constraint",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("document_usage_role",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("dose_equivalent_measure_with_unit",&STEP::ObjectHelper<dose_equivalent_measure_with_unit,0>::Construct )
+,		SchemaEntry("dose_equivalent_unit",&STEP::ObjectHelper<dose_equivalent_unit,0>::Construct )
+,		SchemaEntry("double_offset_shelled_solid",&STEP::ObjectHelper<double_offset_shelled_solid,1>::Construct )
+,		SchemaEntry("item_defined_transformation",&STEP::ObjectHelper<item_defined_transformation,4>::Construct )
+,		SchemaEntry("transformation_with_derived_angle",&STEP::ObjectHelper<transformation_with_derived_angle,0>::Construct )
+,		SchemaEntry("draped_defined_transformation",&STEP::ObjectHelper<draped_defined_transformation,0>::Construct )
+,		SchemaEntry("draughting_annotation_occurrence",&STEP::ObjectHelper<draughting_annotation_occurrence,0>::Construct )
+,		SchemaEntry("draughting_elements",&STEP::ObjectHelper<draughting_elements,0>::Construct )
+,		SchemaEntry("draughting_model",&STEP::ObjectHelper<draughting_model,0>::Construct )
+,		SchemaEntry("item_identified_representation_usage",&STEP::ObjectHelper<item_identified_representation_usage,5>::Construct )
+,		SchemaEntry("draughting_model_item_association",&STEP::ObjectHelper<draughting_model_item_association,0>::Construct )
+,		SchemaEntry("pre_defined_colour",&STEP::ObjectHelper<pre_defined_colour,0>::Construct )
+,		SchemaEntry("draughting_pre_defined_colour",&STEP::ObjectHelper<draughting_pre_defined_colour,0>::Construct )
+,		SchemaEntry("pre_defined_item",&STEP::ObjectHelper<pre_defined_item,1>::Construct )
+,		SchemaEntry("pre_defined_curve_font",&STEP::ObjectHelper<pre_defined_curve_font,0>::Construct )
+,		SchemaEntry("draughting_pre_defined_curve_font",&STEP::ObjectHelper<draughting_pre_defined_curve_font,0>::Construct )
+,		SchemaEntry("pre_defined_text_font",&STEP::ObjectHelper<pre_defined_text_font,0>::Construct )
+,		SchemaEntry("draughting_pre_defined_text_font",&STEP::ObjectHelper<draughting_pre_defined_text_font,0>::Construct )
+,		SchemaEntry("draughting_subfigure_representation",&STEP::ObjectHelper<draughting_subfigure_representation,0>::Construct )
+,		SchemaEntry("draughting_symbol_representation",&STEP::ObjectHelper<draughting_symbol_representation,0>::Construct )
+,		SchemaEntry("text_literal",&STEP::ObjectHelper<text_literal,5>::Construct )
+,		SchemaEntry("text_literal_with_delineation",&STEP::ObjectHelper<text_literal_with_delineation,1>::Construct )
+,		SchemaEntry("draughting_text_literal_with_delineation",&STEP::ObjectHelper<draughting_text_literal_with_delineation,0>::Construct )
+,		SchemaEntry("draughting_title",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("drawing_definition",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("presentation_set",&STEP::ObjectHelper<presentation_set,0>::Construct )
+,		SchemaEntry("drawing_revision",&STEP::ObjectHelper<drawing_revision,3>::Construct )
+,		SchemaEntry("drawing_revision_sequence",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("presentation_representation",&STEP::ObjectHelper<presentation_representation,0>::Construct )
+,		SchemaEntry("presentation_area",&STEP::ObjectHelper<presentation_area,0>::Construct )
+,		SchemaEntry("drawing_sheet_revision",&STEP::ObjectHelper<drawing_sheet_revision,1>::Construct )
+,		SchemaEntry("drawing_sheet_revision_sequence",&STEP::ObjectHelper<drawing_sheet_revision_sequence,0>::Construct )
+,		SchemaEntry("drawing_sheet_revision_usage",&STEP::ObjectHelper<drawing_sheet_revision_usage,1>::Construct )
+,		SchemaEntry("edge",&STEP::ObjectHelper<edge,2>::Construct )
+,		SchemaEntry("edge_based_wireframe_model",&STEP::ObjectHelper<edge_based_wireframe_model,1>::Construct )
+,		SchemaEntry("edge_based_wireframe_shape_representation",&STEP::ObjectHelper<edge_based_wireframe_shape_representation,0>::Construct )
+,		SchemaEntry("edge_blended_solid",&STEP::ObjectHelper<edge_blended_solid,1>::Construct )
+,		SchemaEntry("edge_curve",&STEP::ObjectHelper<edge_curve,2>::Construct )
+,		SchemaEntry("edge_loop",&STEP::ObjectHelper<edge_loop,0>::Construct )
+,		SchemaEntry("effectivity_context_role",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("effectivity_relationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("electric_charge_measure_with_unit",&STEP::ObjectHelper<electric_charge_measure_with_unit,0>::Construct )
+,		SchemaEntry("electric_charge_unit",&STEP::ObjectHelper<electric_charge_unit,0>::Construct )
+,		SchemaEntry("electric_current_measure_with_unit",&STEP::ObjectHelper<electric_current_measure_with_unit,0>::Construct )
+,		SchemaEntry("electric_current_unit",&STEP::ObjectHelper<electric_current_unit,0>::Construct )
+,		SchemaEntry("electric_potential_measure_with_unit",&STEP::ObjectHelper<electric_potential_measure_with_unit,0>::Construct )
+,		SchemaEntry("electric_potential_unit",&STEP::ObjectHelper<electric_potential_unit,0>::Construct )
+,		SchemaEntry("elementary_brep_shape_representation",&STEP::ObjectHelper<elementary_brep_shape_representation,0>::Construct )
+,		SchemaEntry("ellipse",&STEP::ObjectHelper<ellipse,2>::Construct )
+,		SchemaEntry("energy_measure_with_unit",&STEP::ObjectHelper<energy_measure_with_unit,0>::Construct )
+,		SchemaEntry("energy_unit",&STEP::ObjectHelper<energy_unit,0>::Construct )
+,		SchemaEntry("property_definition",&STEP::ObjectHelper<property_definition,3>::Construct )
+,		SchemaEntry("fact_type",&STEP::ObjectHelper<fact_type,0>::Construct )
+,		SchemaEntry("entity_assertion",&STEP::ObjectHelper<entity_assertion,0>::Construct )
+,		SchemaEntry("enum_reference_prefix",&STEP::ObjectHelper<enum_reference_prefix,0>::Construct )
+,		SchemaEntry("environment",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("evaluated_characteristic",&STEP::ObjectHelper<evaluated_characteristic,0>::Construct )
+,		SchemaEntry("evaluated_degenerate_pcurve",&STEP::ObjectHelper<evaluated_degenerate_pcurve,1>::Construct )
+,		SchemaEntry("evaluation_product_definition",&STEP::ObjectHelper<evaluation_product_definition,0>::Construct )
+,		SchemaEntry("event_occurrence",&STEP::ObjectHelper<event_occurrence,3>::Construct )
+,		SchemaEntry("event_occurrence_relationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("event_occurrence_role",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("product_concept_feature_category",&STEP::ObjectHelper<product_concept_feature_category,0>::Construct )
+,		SchemaEntry("exclusive_product_concept_feature_category",&STEP::ObjectHelper<exclusive_product_concept_feature_category,0>::Construct )
+,		SchemaEntry("uncertainty_qualifier",&STEP::ObjectHelper<uncertainty_qualifier,2>::Construct )
+,		SchemaEntry("standard_uncertainty",&STEP::ObjectHelper<standard_uncertainty,1>::Construct )
+,		SchemaEntry("expanded_uncertainty",&STEP::ObjectHelper<expanded_uncertainty,1>::Construct )
+,		SchemaEntry("representation_item_relationship",&STEP::ObjectHelper<representation_item_relationship,4>::Construct )
+,		SchemaEntry("explicit_procedural_representation_item_relationship",&STEP::ObjectHelper<explicit_procedural_representation_item_relationship,0>::Construct )
+,		SchemaEntry("explicit_procedural_geometric_representation_item_relationship",&STEP::ObjectHelper<explicit_procedural_geometric_representation_item_relationship,0>::Construct )
+,		SchemaEntry("explicit_procedural_representation_relationship",&STEP::ObjectHelper<explicit_procedural_representation_relationship,0>::Construct )
+,		SchemaEntry("explicit_procedural_shape_representation_relationship",&STEP::ObjectHelper<explicit_procedural_shape_representation_relationship,0>::Construct )
+,		SchemaEntry("expression_conversion_based_unit",&STEP::ObjectHelper<expression_conversion_based_unit,0>::Construct )
+,		SchemaEntry("extension",&STEP::ObjectHelper<extension,0>::Construct )
+,		SchemaEntry("extent",&STEP::ObjectHelper<extent,0>::Construct )
+,		SchemaEntry("external_source",&STEP::ObjectHelper<external_source,1>::Construct )
+,		SchemaEntry("external_class_library",&STEP::ObjectHelper<external_class_library,0>::Construct )
+,		SchemaEntry("external_source_relationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("externally_defined_class",&STEP::ObjectHelper<externally_defined_class,0>::Construct )
+,		SchemaEntry("externally_defined_colour",&STEP::ObjectHelper<externally_defined_colour,0>::Construct )
+,		SchemaEntry("externally_defined_context_dependent_unit",&STEP::ObjectHelper<externally_defined_context_dependent_unit,0>::Construct )
+,		SchemaEntry("externally_defined_conversion_based_unit",&STEP::ObjectHelper<externally_defined_conversion_based_unit,0>::Construct )
+,		SchemaEntry("externally_defined_currency",&STEP::ObjectHelper<externally_defined_currency,0>::Construct )
+,		SchemaEntry("externally_defined_item",&STEP::ObjectHelper<externally_defined_item,2>::Construct )
+,		SchemaEntry("externally_defined_curve_font",&STEP::ObjectHelper<externally_defined_curve_font,0>::Construct )
+,		SchemaEntry("externally_defined_dimension_definition",&STEP::ObjectHelper<externally_defined_dimension_definition,0>::Construct )
+,		SchemaEntry("externally_defined_general_property",&STEP::ObjectHelper<externally_defined_general_property,0>::Construct )
+,		SchemaEntry("externally_defined_hatch_style",&STEP::ObjectHelper<externally_defined_hatch_style,0>::Construct )
+,		SchemaEntry("externally_defined_item_relationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("externally_defined_marker",&STEP::ObjectHelper<externally_defined_marker,0>::Construct )
+,		SchemaEntry("picture_representation_item",&STEP::ObjectHelper<picture_representation_item,0>::Construct )
+,		SchemaEntry("externally_defined_picture_representation_item",&STEP::ObjectHelper<externally_defined_picture_representation_item,0>::Construct )
+,		SchemaEntry("externally_defined_representation_item",&STEP::ObjectHelper<externally_defined_representation_item,0>::Construct )
+,		SchemaEntry("externally_defined_string",&STEP::ObjectHelper<externally_defined_string,0>::Construct )
+,		SchemaEntry("externally_defined_symbol",&STEP::ObjectHelper<externally_defined_symbol,0>::Construct )
+,		SchemaEntry("externally_defined_terminator_symbol",&STEP::ObjectHelper<externally_defined_terminator_symbol,0>::Construct )
+,		SchemaEntry("externally_defined_text_font",&STEP::ObjectHelper<externally_defined_text_font,0>::Construct )
+,		SchemaEntry("externally_defined_tile",&STEP::ObjectHelper<externally_defined_tile,0>::Construct )
+,		SchemaEntry("externally_defined_tile_style",&STEP::ObjectHelper<externally_defined_tile_style,0>::Construct )
+,		SchemaEntry("swept_area_solid",&STEP::ObjectHelper<swept_area_solid,1>::Construct )
+,		SchemaEntry("extruded_area_solid",&STEP::ObjectHelper<extruded_area_solid,2>::Construct )
+,		SchemaEntry("swept_face_solid",&STEP::ObjectHelper<swept_face_solid,1>::Construct )
+,		SchemaEntry("extruded_face_solid",&STEP::ObjectHelper<extruded_face_solid,2>::Construct )
+,		SchemaEntry("extruded_face_solid_with_trim_conditions",&STEP::ObjectHelper<extruded_face_solid_with_trim_conditions,6>::Construct )
+,		SchemaEntry("extruded_face_solid_with_draft_angle",&STEP::ObjectHelper<extruded_face_solid_with_draft_angle,1>::Construct )
+,		SchemaEntry("extruded_face_solid_with_multiple_draft_angles",&STEP::ObjectHelper<extruded_face_solid_with_multiple_draft_angles,1>::Construct )
+,		SchemaEntry("face",&STEP::ObjectHelper<face,1>::Construct )
+,		SchemaEntry("face_based_surface_model",&STEP::ObjectHelper<face_based_surface_model,1>::Construct )
+,		SchemaEntry("face_bound",&STEP::ObjectHelper<face_bound,2>::Construct )
+,		SchemaEntry("face_outer_bound",&STEP::ObjectHelper<face_outer_bound,0>::Construct )
+,		SchemaEntry("faceted_brep",&STEP::ObjectHelper<faceted_brep,0>::Construct )
+,		SchemaEntry("faceted_brep_shape_representation",&STEP::ObjectHelper<faceted_brep_shape_representation,0>::Construct )
+,		SchemaEntry("fill_area_style",&STEP::ObjectHelper<fill_area_style,2>::Construct )
+,		SchemaEntry("fill_area_style_colour",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("fill_area_style_hatching",&STEP::ObjectHelper<fill_area_style_hatching,5>::Construct )
+,		SchemaEntry("fill_area_style_tile_coloured_region",&STEP::ObjectHelper<fill_area_style_tile_coloured_region,2>::Construct )
+,		SchemaEntry("fill_area_style_tile_curve_with_style",&STEP::ObjectHelper<fill_area_style_tile_curve_with_style,1>::Construct )
+,		SchemaEntry("fill_area_style_tile_symbol_with_style",&STEP::ObjectHelper<fill_area_style_tile_symbol_with_style,1>::Construct )
+,		SchemaEntry("fill_area_style_tiles",&STEP::ObjectHelper<fill_area_style_tiles,3>::Construct )
+,		SchemaEntry("shape_representation_relationship",&STEP::ObjectHelper<shape_representation_relationship,0>::Construct )
+,		SchemaEntry("flat_pattern_ply_representation_relationship",&STEP::ObjectHelper<flat_pattern_ply_representation_relationship,0>::Construct )
+,		SchemaEntry("flatness_tolerance",&STEP::ObjectHelper<flatness_tolerance,0>::Construct )
+,		SchemaEntry("force_measure_with_unit",&STEP::ObjectHelper<force_measure_with_unit,0>::Construct )
+,		SchemaEntry("force_unit",&STEP::ObjectHelper<force_unit,0>::Construct )
+,		SchemaEntry("forward_chaining_rule",&STEP::ObjectHelper<forward_chaining_rule,0>::Construct )
+,		SchemaEntry("forward_chaining_rule_premise",&STEP::ObjectHelper<forward_chaining_rule_premise,0>::Construct )
+,		SchemaEntry("frequency_measure_with_unit",&STEP::ObjectHelper<frequency_measure_with_unit,0>::Construct )
+,		SchemaEntry("frequency_unit",&STEP::ObjectHelper<frequency_unit,0>::Construct )
+,		SchemaEntry("func",&STEP::ObjectHelper<func,0>::Construct )
+,		SchemaEntry("functional_breakdown_context",&STEP::ObjectHelper<functional_breakdown_context,0>::Construct )
+,		SchemaEntry("functional_element_usage",&STEP::ObjectHelper<functional_element_usage,0>::Construct )
+,		SchemaEntry("functionally_defined_transformation",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("general_material_property",&STEP::ObjectHelper<general_material_property,0>::Construct )
+,		SchemaEntry("general_property_association",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("simple_generic_expression",&STEP::ObjectHelper<simple_generic_expression,0>::Construct )
+,		SchemaEntry("generic_literal",&STEP::ObjectHelper<generic_literal,0>::Construct )
+,		SchemaEntry("generic_variable",&STEP::ObjectHelper<generic_variable,0>::Construct )
+,		SchemaEntry("geometric_alignment",&STEP::ObjectHelper<geometric_alignment,0>::Construct )
+,		SchemaEntry("geometric_set",&STEP::ObjectHelper<geometric_set,1>::Construct )
+,		SchemaEntry("geometric_curve_set",&STEP::ObjectHelper<geometric_curve_set,0>::Construct )
+,		SchemaEntry("geometric_intersection",&STEP::ObjectHelper<geometric_intersection,0>::Construct )
+,		SchemaEntry("geometric_item_specific_usage",&STEP::ObjectHelper<geometric_item_specific_usage,0>::Construct )
+,		SchemaEntry("geometric_model_element_relationship",&STEP::ObjectHelper<geometric_model_element_relationship,0>::Construct )
+,		SchemaEntry("representation_context",&STEP::ObjectHelper<representation_context,2>::Construct )
+,		SchemaEntry("geometric_representation_context",&STEP::ObjectHelper<geometric_representation_context,1>::Construct )
+,		SchemaEntry("geometric_tolerance_relationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("geometric_tolerance_with_defined_unit",&STEP::ObjectHelper<geometric_tolerance_with_defined_unit,1>::Construct )
+,		SchemaEntry("geometrical_tolerance_callout",&STEP::ObjectHelper<geometrical_tolerance_callout,0>::Construct )
+,		SchemaEntry("geometrically_bounded_2d_wireframe_representation",&STEP::ObjectHelper<geometrically_bounded_2d_wireframe_representation,0>::Construct )
+,		SchemaEntry("geometrically_bounded_surface_shape_representation",&STEP::ObjectHelper<geometrically_bounded_surface_shape_representation,0>::Construct )
+,		SchemaEntry("geometrically_bounded_wireframe_shape_representation",&STEP::ObjectHelper<geometrically_bounded_wireframe_shape_representation,0>::Construct )
+,		SchemaEntry("global_assignment",&STEP::ObjectHelper<global_assignment,0>::Construct )
+,		SchemaEntry("global_uncertainty_assigned_context",&STEP::ObjectHelper<global_uncertainty_assigned_context,1>::Construct )
+,		SchemaEntry("global_unit_assigned_context",&STEP::ObjectHelper<global_unit_assigned_context,1>::Construct )
+,		SchemaEntry("ground_fact",&STEP::ObjectHelper<ground_fact,0>::Construct )
+,		SchemaEntry("group_relationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("hardness_representation",&STEP::ObjectHelper<hardness_representation,0>::Construct )
+,		SchemaEntry("hidden_element_over_riding_styled_item",&STEP::ObjectHelper<hidden_element_over_riding_styled_item,0>::Construct )
+,		SchemaEntry("hyperbola",&STEP::ObjectHelper<hyperbola,2>::Construct )
+,		SchemaEntry("id_attribute",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("identification_role",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("illuminance_measure_with_unit",&STEP::ObjectHelper<illuminance_measure_with_unit,0>::Construct )
+,		SchemaEntry("illuminance_unit",&STEP::ObjectHelper<illuminance_unit,0>::Construct )
+,		SchemaEntry("included_text_block",&STEP::ObjectHelper<included_text_block,0>::Construct )
+,		SchemaEntry("inclusion_product_concept_feature",&STEP::ObjectHelper<inclusion_product_concept_feature,0>::Construct )
+,		SchemaEntry("user_selected_elements",&STEP::ObjectHelper<user_selected_elements,1>::Construct )
+,		SchemaEntry("indirectly_selected_elements",&STEP::ObjectHelper<indirectly_selected_elements,1>::Construct )
+,		SchemaEntry("indirectly_selected_shape_elements",&STEP::ObjectHelper<indirectly_selected_shape_elements,0>::Construct )
+,		SchemaEntry("inductance_measure_with_unit",&STEP::ObjectHelper<inductance_measure_with_unit,0>::Construct )
+,		SchemaEntry("inductance_unit",&STEP::ObjectHelper<inductance_unit,0>::Construct )
+,		SchemaEntry("information_right",&STEP::ObjectHelper<information_right,0>::Construct )
+,		SchemaEntry("information_usage_right",&STEP::ObjectHelper<information_usage_right,0>::Construct )
+,		SchemaEntry("instance_usage_context_assignment",&STEP::ObjectHelper<instance_usage_context_assignment,1>::Construct )
+,		SchemaEntry("instanced_feature",&STEP::ObjectHelper<instanced_feature,0>::Construct )
+,		SchemaEntry("literal_number",&STEP::ObjectHelper<literal_number,1>::Construct )
+,		SchemaEntry("int_literal",&STEP::ObjectHelper<int_literal,0>::Construct )
+,		SchemaEntry("integer_representation_item",&STEP::ObjectHelper<integer_representation_item,0>::Construct )
+,		SchemaEntry("surface_curve",&STEP::ObjectHelper<surface_curve,3>::Construct )
+,		SchemaEntry("intersection_curve",&STEP::ObjectHelper<intersection_curve,0>::Construct )
+,		SchemaEntry("interval_expression",&STEP::ObjectHelper<interval_expression,0>::Construct )
+,		SchemaEntry("iso4217_currency",&STEP::ObjectHelper<iso4217_currency,0>::Construct )
+,		SchemaEntry("known_source",&STEP::ObjectHelper<known_source,0>::Construct )
+,		SchemaEntry("laid_defined_transformation",&STEP::ObjectHelper<laid_defined_transformation,0>::Construct )
+,		SchemaEntry("language",&STEP::ObjectHelper<language,0>::Construct )
+,		SchemaEntry("leader_curve",&STEP::ObjectHelper<leader_curve,0>::Construct )
+,		SchemaEntry("leader_directed_callout",&STEP::ObjectHelper<leader_directed_callout,0>::Construct )
+,		SchemaEntry("leader_directed_dimension",&STEP::ObjectHelper<leader_directed_dimension,0>::Construct )
+,		SchemaEntry("leader_terminator",&STEP::ObjectHelper<leader_terminator,0>::Construct )
+,		SchemaEntry("length_measure_with_unit",&STEP::ObjectHelper<length_measure_with_unit,0>::Construct )
+,		SchemaEntry("length_unit",&STEP::ObjectHelper<length_unit,0>::Construct )
+,		SchemaEntry("light_source",&STEP::ObjectHelper<light_source,1>::Construct )
+,		SchemaEntry("light_source_ambient",&STEP::ObjectHelper<light_source_ambient,0>::Construct )
+,		SchemaEntry("light_source_directional",&STEP::ObjectHelper<light_source_directional,1>::Construct )
+,		SchemaEntry("light_source_positional",&STEP::ObjectHelper<light_source_positional,3>::Construct )
+,		SchemaEntry("light_source_spot",&STEP::ObjectHelper<light_source_spot,6>::Construct )
+,		SchemaEntry("limits_and_fits",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("line",&STEP::ObjectHelper<line,2>::Construct )
+,		SchemaEntry("line_profile_tolerance",&STEP::ObjectHelper<line_profile_tolerance,0>::Construct )
+,		SchemaEntry("linear_dimension",&STEP::ObjectHelper<linear_dimension,0>::Construct )
+,		SchemaEntry("simple_clause",&STEP::ObjectHelper<simple_clause,0>::Construct )
+,		SchemaEntry("literal_conjunction",&STEP::ObjectHelper<literal_conjunction,0>::Construct )
+,		SchemaEntry("literal_disjunction",&STEP::ObjectHelper<literal_disjunction,0>::Construct )
+,		SchemaEntry("local_time",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("logical_literal",&STEP::ObjectHelper<logical_literal,1>::Construct )
+,		SchemaEntry("logical_representation_item",&STEP::ObjectHelper<logical_representation_item,0>::Construct )
+,		SchemaEntry("loop",&STEP::ObjectHelper<loop,0>::Construct )
+,		SchemaEntry("loss_tangent_measure_with_unit",&STEP::ObjectHelper<loss_tangent_measure_with_unit,0>::Construct )
+,		SchemaEntry("lot_effectivity",&STEP::ObjectHelper<lot_effectivity,2>::Construct )
+,		SchemaEntry("luminous_flux_measure_with_unit",&STEP::ObjectHelper<luminous_flux_measure_with_unit,0>::Construct )
+,		SchemaEntry("luminous_flux_unit",&STEP::ObjectHelper<luminous_flux_unit,0>::Construct )
+,		SchemaEntry("luminous_intensity_measure_with_unit",&STEP::ObjectHelper<luminous_intensity_measure_with_unit,0>::Construct )
+,		SchemaEntry("luminous_intensity_unit",&STEP::ObjectHelper<luminous_intensity_unit,0>::Construct )
+,		SchemaEntry("magnetic_flux_density_measure_with_unit",&STEP::ObjectHelper<magnetic_flux_density_measure_with_unit,0>::Construct )
+,		SchemaEntry("magnetic_flux_density_unit",&STEP::ObjectHelper<magnetic_flux_density_unit,0>::Construct )
+,		SchemaEntry("magnetic_flux_measure_with_unit",&STEP::ObjectHelper<magnetic_flux_measure_with_unit,0>::Construct )
+,		SchemaEntry("magnetic_flux_unit",&STEP::ObjectHelper<magnetic_flux_unit,0>::Construct )
+,		SchemaEntry("make_from_usage_option",&STEP::ObjectHelper<make_from_usage_option,3>::Construct )
+,		SchemaEntry("manifold_subsurface_shape_representation",&STEP::ObjectHelper<manifold_subsurface_shape_representation,0>::Construct )
+,		SchemaEntry("manifold_surface_shape_representation",&STEP::ObjectHelper<manifold_surface_shape_representation,0>::Construct )
+,		SchemaEntry("mass_measure_with_unit",&STEP::ObjectHelper<mass_measure_with_unit,0>::Construct )
+,		SchemaEntry("mass_unit",&STEP::ObjectHelper<mass_unit,0>::Construct )
+,		SchemaEntry("material_designation_characterization",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("material_property",&STEP::ObjectHelper<material_property,0>::Construct )
+,		SchemaEntry("property_definition_representation",&STEP::ObjectHelper<property_definition_representation,2>::Construct )
+,		SchemaEntry("material_property_representation",&STEP::ObjectHelper<material_property_representation,1>::Construct )
+,		SchemaEntry("measure_qualification",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("measure_representation_item",&STEP::ObjectHelper<measure_representation_item,0>::Construct )
+,		SchemaEntry("product_context",&STEP::ObjectHelper<product_context,1>::Construct )
+,		SchemaEntry("mechanical_context",&STEP::ObjectHelper<mechanical_context,0>::Construct )
+,		SchemaEntry("mechanical_design_and_draughting_relationship",&STEP::ObjectHelper<mechanical_design_and_draughting_relationship,0>::Construct )
+,		SchemaEntry("mechanical_design_geometric_presentation_area",&STEP::ObjectHelper<mechanical_design_geometric_presentation_area,0>::Construct )
+,		SchemaEntry("mechanical_design_geometric_presentation_representation",&STEP::ObjectHelper<mechanical_design_geometric_presentation_representation,0>::Construct )
+,		SchemaEntry("mechanical_design_presentation_representation_with_draughting",&STEP::ObjectHelper<mechanical_design_presentation_representation_with_draughting,0>::Construct )
+,		SchemaEntry("mechanical_design_shaded_presentation_area",&STEP::ObjectHelper<mechanical_design_shaded_presentation_area,0>::Construct )
+,		SchemaEntry("mechanical_design_shaded_presentation_representation",&STEP::ObjectHelper<mechanical_design_shaded_presentation_representation,0>::Construct )
+,		SchemaEntry("min_and_major_ply_orientation_basis",&STEP::ObjectHelper<min_and_major_ply_orientation_basis,0>::Construct )
+,		SchemaEntry("modified_geometric_tolerance",&STEP::ObjectHelper<modified_geometric_tolerance,1>::Construct )
+,		SchemaEntry("modified_solid_with_placed_configuration",&STEP::ObjectHelper<modified_solid_with_placed_configuration,1>::Construct )
+,		SchemaEntry("moments_of_inertia_representation",&STEP::ObjectHelper<moments_of_inertia_representation,0>::Construct )
+,		SchemaEntry("multi_language_attribute_assignment",&STEP::ObjectHelper<multi_language_attribute_assignment,1>::Construct )
+,		SchemaEntry("multiple_arity_boolean_expression",&STEP::ObjectHelper<multiple_arity_boolean_expression,0>::Construct )
+,		SchemaEntry("multiple_arity_generic_expression",&STEP::ObjectHelper<multiple_arity_generic_expression,1>::Construct )
+,		SchemaEntry("multiple_arity_numeric_expression",&STEP::ObjectHelper<multiple_arity_numeric_expression,0>::Construct )
+,		SchemaEntry("name_attribute",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("next_assembly_usage_occurrence",&STEP::ObjectHelper<next_assembly_usage_occurrence,0>::Construct )
+,		SchemaEntry("non_manifold_surface_shape_representation",&STEP::ObjectHelper<non_manifold_surface_shape_representation,0>::Construct )
+,		SchemaEntry("null_representation_item",&STEP::ObjectHelper<null_representation_item,0>::Construct )
+,		SchemaEntry("numeric_expression",&STEP::ObjectHelper<numeric_expression,0>::Construct )
+,		SchemaEntry("object_role",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("offset_curve_2d",&STEP::ObjectHelper<offset_curve_2d,3>::Construct )
+,		SchemaEntry("offset_curve_3d",&STEP::ObjectHelper<offset_curve_3d,4>::Construct )
+,		SchemaEntry("offset_surface",&STEP::ObjectHelper<offset_surface,3>::Construct )
+,		SchemaEntry("one_direction_repeat_factor",&STEP::ObjectHelper<one_direction_repeat_factor,1>::Construct )
+,		SchemaEntry("open_shell",&STEP::ObjectHelper<open_shell,0>::Construct )
+,		SchemaEntry("ordinal_date",&STEP::ObjectHelper<ordinal_date,1>::Construct )
+,		SchemaEntry("projection_directed_callout",&STEP::ObjectHelper<projection_directed_callout,0>::Construct )
+,		SchemaEntry("ordinate_dimension",&STEP::ObjectHelper<ordinate_dimension,0>::Construct )
+,		SchemaEntry("organization",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("organization_relationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("organization_role",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("organizational_address",&STEP::ObjectHelper<organizational_address,2>::Construct )
+,		SchemaEntry("organizational_project",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("organizational_project_relationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("organizational_project_role",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("oriented_closed_shell",&STEP::ObjectHelper<oriented_closed_shell,2>::Construct )
+,		SchemaEntry("oriented_edge",&STEP::ObjectHelper<oriented_edge,2>::Construct )
+,		SchemaEntry("oriented_face",&STEP::ObjectHelper<oriented_face,2>::Construct )
+,		SchemaEntry("oriented_open_shell",&STEP::ObjectHelper<oriented_open_shell,2>::Construct )
+,		SchemaEntry("path",&STEP::ObjectHelper<path,1>::Construct )
+,		SchemaEntry("oriented_path",&STEP::ObjectHelper<oriented_path,2>::Construct )
+,		SchemaEntry("oriented_surface",&STEP::ObjectHelper<oriented_surface,1>::Construct )
+,		SchemaEntry("outer_boundary_curve",&STEP::ObjectHelper<outer_boundary_curve,0>::Construct )
+,		SchemaEntry("package_product_concept_feature",&STEP::ObjectHelper<package_product_concept_feature,0>::Construct )
+,		SchemaEntry("parabola",&STEP::ObjectHelper<parabola,1>::Construct )
+,		SchemaEntry("parallel_offset",&STEP::ObjectHelper<parallel_offset,1>::Construct )
+,		SchemaEntry("parallelism_tolerance",&STEP::ObjectHelper<parallelism_tolerance,0>::Construct )
+,		SchemaEntry("parametric_representation_context",&STEP::ObjectHelper<parametric_representation_context,0>::Construct )
+,		SchemaEntry("partial_document_with_structured_text_representation_assignment",&STEP::ObjectHelper<partial_document_with_structured_text_representation_assignment,0>::Construct )
+,		SchemaEntry("pcurve",&STEP::ObjectHelper<pcurve,2>::Construct )
+,		SchemaEntry("percentage_laminate_definition",&STEP::ObjectHelper<percentage_laminate_definition,0>::Construct )
+,		SchemaEntry("zone_structural_makeup",&STEP::ObjectHelper<zone_structural_makeup,0>::Construct )
+,		SchemaEntry("percentage_laminate_table",&STEP::ObjectHelper<percentage_laminate_table,0>::Construct )
+,		SchemaEntry("percentage_ply_definition",&STEP::ObjectHelper<percentage_ply_definition,0>::Construct )
+,		SchemaEntry("perpendicular_to",&STEP::ObjectHelper<perpendicular_to,0>::Construct )
+,		SchemaEntry("perpendicularity_tolerance",&STEP::ObjectHelper<perpendicularity_tolerance,0>::Construct )
+,		SchemaEntry("person",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("person_and_organization",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("person_and_organization_address",&STEP::ObjectHelper<person_and_organization_address,0>::Construct )
+,		SchemaEntry("person_and_organization_role",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("personal_address",&STEP::ObjectHelper<personal_address,2>::Construct )
+,		SchemaEntry("physical_breakdown_context",&STEP::ObjectHelper<physical_breakdown_context,0>::Construct )
+,		SchemaEntry("physical_element_usage",&STEP::ObjectHelper<physical_element_usage,0>::Construct )
+,		SchemaEntry("presentation_view",&STEP::ObjectHelper<presentation_view,0>::Construct )
+,		SchemaEntry("picture_representation",&STEP::ObjectHelper<picture_representation,0>::Construct )
+,		SchemaEntry("placed_datum_target_feature",&STEP::ObjectHelper<placed_datum_target_feature,0>::Construct )
+,		SchemaEntry("placed_feature",&STEP::ObjectHelper<placed_feature,0>::Construct )
+,		SchemaEntry("planar_extent",&STEP::ObjectHelper<planar_extent,2>::Construct )
+,		SchemaEntry("planar_box",&STEP::ObjectHelper<planar_box,1>::Construct )
+,		SchemaEntry("plane",&STEP::ObjectHelper<plane,0>::Construct )
+,		SchemaEntry("plane_angle_measure_with_unit",&STEP::ObjectHelper<plane_angle_measure_with_unit,0>::Construct )
+,		SchemaEntry("plane_angle_unit",&STEP::ObjectHelper<plane_angle_unit,0>::Construct )
+,		SchemaEntry("plus_minus_tolerance",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("ply_laminate_definition",&STEP::ObjectHelper<ply_laminate_definition,0>::Construct )
+,		SchemaEntry("ply_laminate_sequence_definition",&STEP::ObjectHelper<ply_laminate_sequence_definition,0>::Construct )
+,		SchemaEntry("ply_laminate_table",&STEP::ObjectHelper<ply_laminate_table,0>::Construct )
+,		SchemaEntry("point_and_vector",&STEP::ObjectHelper<point_and_vector,0>::Construct )
+,		SchemaEntry("point_on_curve",&STEP::ObjectHelper<point_on_curve,2>::Construct )
+,		SchemaEntry("point_on_surface",&STEP::ObjectHelper<point_on_surface,3>::Construct )
+,		SchemaEntry("point_path",&STEP::ObjectHelper<point_path,0>::Construct )
+,		SchemaEntry("point_replica",&STEP::ObjectHelper<point_replica,2>::Construct )
+,		SchemaEntry("point_style",&STEP::ObjectHelper<point_style,4>::Construct )
+,		SchemaEntry("polar_complex_number_literal",&STEP::ObjectHelper<polar_complex_number_literal,2>::Construct )
+,		SchemaEntry("poly_loop",&STEP::ObjectHelper<poly_loop,1>::Construct )
+,		SchemaEntry("polyline",&STEP::ObjectHelper<polyline,1>::Construct )
+,		SchemaEntry("position_tolerance",&STEP::ObjectHelper<position_tolerance,0>::Construct )
+,		SchemaEntry("positioned_sketch",&STEP::ObjectHelper<positioned_sketch,2>::Construct )
+,		SchemaEntry("power_measure_with_unit",&STEP::ObjectHelper<power_measure_with_unit,0>::Construct )
+,		SchemaEntry("power_unit",&STEP::ObjectHelper<power_unit,0>::Construct )
+,		SchemaEntry("pre_defined_symbol",&STEP::ObjectHelper<pre_defined_symbol,0>::Construct )
+,		SchemaEntry("pre_defined_dimension_symbol",&STEP::ObjectHelper<pre_defined_dimension_symbol,0>::Construct )
+,		SchemaEntry("pre_defined_geometrical_tolerance_symbol",&STEP::ObjectHelper<pre_defined_geometrical_tolerance_symbol,0>::Construct )
+,		SchemaEntry("pre_defined_marker",&STEP::ObjectHelper<pre_defined_marker,0>::Construct )
+,		SchemaEntry("pre_defined_point_marker_symbol",&STEP::ObjectHelper<pre_defined_point_marker_symbol,0>::Construct )
+,		SchemaEntry("pre_defined_surface_condition_symbol",&STEP::ObjectHelper<pre_defined_surface_condition_symbol,0>::Construct )
+,		SchemaEntry("pre_defined_surface_side_style",&STEP::ObjectHelper<pre_defined_surface_side_style,0>::Construct )
+,		SchemaEntry("pre_defined_terminator_symbol",&STEP::ObjectHelper<pre_defined_terminator_symbol,0>::Construct )
+,		SchemaEntry("pre_defined_tile",&STEP::ObjectHelper<pre_defined_tile,0>::Construct )
+,		SchemaEntry("precision_qualifier",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("predefined_picture_representation_item",&STEP::ObjectHelper<predefined_picture_representation_item,0>::Construct )
+,		SchemaEntry("presentation_layer_assignment",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("presentation_size",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("presentation_style_assignment",&STEP::ObjectHelper<presentation_style_assignment,1>::Construct )
+,		SchemaEntry("presentation_style_by_context",&STEP::ObjectHelper<presentation_style_by_context,1>::Construct )
+,		SchemaEntry("presented_item_representation",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("pressure_measure_with_unit",&STEP::ObjectHelper<pressure_measure_with_unit,0>::Construct )
+,		SchemaEntry("pressure_unit",&STEP::ObjectHelper<pressure_unit,0>::Construct )
+,		SchemaEntry("procedural_representation",&STEP::ObjectHelper<procedural_representation,0>::Construct )
+,		SchemaEntry("procedural_representation_sequence",&STEP::ObjectHelper<procedural_representation_sequence,3>::Construct )
+,		SchemaEntry("procedural_shape_representation",&STEP::ObjectHelper<procedural_shape_representation,0>::Construct )
+,		SchemaEntry("procedural_shape_representation_sequence",&STEP::ObjectHelper<procedural_shape_representation_sequence,0>::Construct )
+,		SchemaEntry("product",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("product_category",&STEP::ObjectHelper<product_category,2>::Construct )
+,		SchemaEntry("product_class",&STEP::ObjectHelper<product_class,0>::Construct )
+,		SchemaEntry("product_concept",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("product_concept_context",&STEP::ObjectHelper<product_concept_context,1>::Construct )
+,		SchemaEntry("product_concept_feature_association",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("product_concept_feature_category_usage",&STEP::ObjectHelper<product_concept_feature_category_usage,1>::Construct )
+,		SchemaEntry("product_concept_relationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("product_definition_context_association",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("product_definition_context_role",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("product_definition_element_relationship",&STEP::ObjectHelper<product_definition_element_relationship,0>::Construct )
+,		SchemaEntry("product_definition_formation",&STEP::ObjectHelper<product_definition_formation,3>::Construct )
+,		SchemaEntry("product_definition_formation_relationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("product_definition_formation_with_specified_source",&STEP::ObjectHelper<product_definition_formation_with_specified_source,1>::Construct )
+,		SchemaEntry("product_definition_group_assignment",&STEP::ObjectHelper<product_definition_group_assignment,1>::Construct )
+,		SchemaEntry("product_definition_occurrence_relationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("product_definition_shape",&STEP::ObjectHelper<product_definition_shape,0>::Construct )
+,		SchemaEntry("product_definition_substitute",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("product_definition_with_associated_documents",&STEP::ObjectHelper<product_definition_with_associated_documents,1>::Construct )
+,		SchemaEntry("product_identification",&STEP::ObjectHelper<product_identification,0>::Construct )
+,		SchemaEntry("product_material_composition_relationship",&STEP::ObjectHelper<product_material_composition_relationship,4>::Construct )
+,		SchemaEntry("product_related_product_category",&STEP::ObjectHelper<product_related_product_category,1>::Construct )
+,		SchemaEntry("product_specification",&STEP::ObjectHelper<product_specification,0>::Construct )
+,		SchemaEntry("tolerance_zone_definition",&STEP::ObjectHelper<tolerance_zone_definition,2>::Construct )
+,		SchemaEntry("projected_zone_definition",&STEP::ObjectHelper<projected_zone_definition,2>::Construct )
+,		SchemaEntry("projection_curve",&STEP::ObjectHelper<projection_curve,0>::Construct )
+,		SchemaEntry("promissory_usage_occurrence",&STEP::ObjectHelper<promissory_usage_occurrence,0>::Construct )
+,		SchemaEntry("property_definition_relationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("qualified_representation_item",&STEP::ObjectHelper<qualified_representation_item,1>::Construct )
+,		SchemaEntry("qualitative_uncertainty",&STEP::ObjectHelper<qualitative_uncertainty,1>::Construct )
+,		SchemaEntry("quantified_assembly_component_usage",&STEP::ObjectHelper<quantified_assembly_component_usage,1>::Construct )
+,		SchemaEntry("quasi_uniform_curve",&STEP::ObjectHelper<quasi_uniform_curve,0>::Construct )
+,		SchemaEntry("quasi_uniform_surface",&STEP::ObjectHelper<quasi_uniform_surface,0>::Construct )
+,		SchemaEntry("radioactivity_measure_with_unit",&STEP::ObjectHelper<radioactivity_measure_with_unit,0>::Construct )
+,		SchemaEntry("radioactivity_unit",&STEP::ObjectHelper<radioactivity_unit,0>::Construct )
+,		SchemaEntry("radius_dimension",&STEP::ObjectHelper<radius_dimension,0>::Construct )
+,		SchemaEntry("range_characteristic",&STEP::ObjectHelper<range_characteristic,0>::Construct )
+,		SchemaEntry("ratio_unit",&STEP::ObjectHelper<ratio_unit,0>::Construct )
+,		SchemaEntry("rational_b_spline_curve",&STEP::ObjectHelper<rational_b_spline_curve,1>::Construct )
+,		SchemaEntry("rational_b_spline_surface",&STEP::ObjectHelper<rational_b_spline_surface,0>::Construct )
+,		SchemaEntry("rational_representation_item",&STEP::ObjectHelper<rational_representation_item,0>::Construct )
+,		SchemaEntry("real_literal",&STEP::ObjectHelper<real_literal,0>::Construct )
+,		SchemaEntry("real_representation_item",&STEP::ObjectHelper<real_representation_item,0>::Construct )
+,		SchemaEntry("rectangular_composite_surface",&STEP::ObjectHelper<rectangular_composite_surface,0>::Construct )
+,		SchemaEntry("rectangular_trimmed_surface",&STEP::ObjectHelper<rectangular_trimmed_surface,7>::Construct )
+,		SchemaEntry("referenced_modified_datum",&STEP::ObjectHelper<referenced_modified_datum,1>::Construct )
+,		SchemaEntry("relative_event_occurrence",&STEP::ObjectHelper<relative_event_occurrence,2>::Construct )
+,		SchemaEntry("rep_item_group",&STEP::ObjectHelper<rep_item_group,0>::Construct )
+,		SchemaEntry("reparametrised_composite_curve_segment",&STEP::ObjectHelper<reparametrised_composite_curve_segment,1>::Construct )
+,		SchemaEntry("representation_relationship_with_transformation",&STEP::ObjectHelper<representation_relationship_with_transformation,1>::Construct )
+,		SchemaEntry("requirement_assigned_object",&STEP::ObjectHelper<requirement_assigned_object,1>::Construct )
+,		SchemaEntry("requirement_assignment",&STEP::ObjectHelper<requirement_assignment,0>::Construct )
+,		SchemaEntry("requirement_source",&STEP::ObjectHelper<requirement_source,0>::Construct )
+,		SchemaEntry("requirement_view_definition_relationship",&STEP::ObjectHelper<requirement_view_definition_relationship,0>::Construct )
+,		SchemaEntry("resistance_measure_with_unit",&STEP::ObjectHelper<resistance_measure_with_unit,0>::Construct )
+,		SchemaEntry("resistance_unit",&STEP::ObjectHelper<resistance_unit,0>::Construct )
+,		SchemaEntry("revolved_area_solid",&STEP::ObjectHelper<revolved_area_solid,2>::Construct )
+,		SchemaEntry("revolved_face_solid",&STEP::ObjectHelper<revolved_face_solid,2>::Construct )
+,		SchemaEntry("revolved_face_solid_with_trim_conditions",&STEP::ObjectHelper<revolved_face_solid_with_trim_conditions,2>::Construct )
+,		SchemaEntry("right_angular_wedge",&STEP::ObjectHelper<right_angular_wedge,5>::Construct )
+,		SchemaEntry("right_circular_cone",&STEP::ObjectHelper<right_circular_cone,4>::Construct )
+,		SchemaEntry("right_circular_cylinder",&STEP::ObjectHelper<right_circular_cylinder,3>::Construct )
+,		SchemaEntry("right_to_usage_association",&STEP::ObjectHelper<right_to_usage_association,0>::Construct )
+,		SchemaEntry("role_association",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("roundness_tolerance",&STEP::ObjectHelper<roundness_tolerance,0>::Construct )
+,		SchemaEntry("row_representation_item",&STEP::ObjectHelper<row_representation_item,0>::Construct )
+,		SchemaEntry("row_value",&STEP::ObjectHelper<row_value,0>::Construct )
+,		SchemaEntry("row_variable",&STEP::ObjectHelper<row_variable,0>::Construct )
+,		SchemaEntry("rule_action",&STEP::ObjectHelper<rule_action,0>::Construct )
+,		SchemaEntry("rule_condition",&STEP::ObjectHelper<rule_condition,0>::Construct )
+,		SchemaEntry("rule_set",&STEP::ObjectHelper<rule_set,0>::Construct )
+,		SchemaEntry("rule_set_group",&STEP::ObjectHelper<rule_set_group,0>::Construct )
+,		SchemaEntry("rule_superseded_assignment",&STEP::ObjectHelper<rule_superseded_assignment,1>::Construct )
+,		SchemaEntry("rule_supersedence",&STEP::ObjectHelper<rule_supersedence,0>::Construct )
+,		SchemaEntry("surface_curve_swept_area_solid",&STEP::ObjectHelper<surface_curve_swept_area_solid,4>::Construct )
+,		SchemaEntry("ruled_surface_swept_area_solid",&STEP::ObjectHelper<ruled_surface_swept_area_solid,0>::Construct )
+,		SchemaEntry("runout_zone_definition",&STEP::ObjectHelper<runout_zone_definition,1>::Construct )
+,		SchemaEntry("runout_zone_orientation",&STEP::ObjectHelper<runout_zone_orientation,1>::Construct )
+,		SchemaEntry("runout_zone_orientation_reference_direction",&STEP::ObjectHelper<runout_zone_orientation_reference_direction,1>::Construct )
+,		SchemaEntry("satisfied_requirement",&STEP::ObjectHelper<satisfied_requirement,1>::Construct )
+,		SchemaEntry("satisfies_requirement",&STEP::ObjectHelper<satisfies_requirement,0>::Construct )
+,		SchemaEntry("satisfying_item",&STEP::ObjectHelper<satisfying_item,1>::Construct )
+,		SchemaEntry("scalar_variable",&STEP::ObjectHelper<scalar_variable,0>::Construct )
+,		SchemaEntry("scattering_parameter",&STEP::ObjectHelper<scattering_parameter,0>::Construct )
+,		SchemaEntry("sculptured_solid",&STEP::ObjectHelper<sculptured_solid,2>::Construct )
+,		SchemaEntry("seam_curve",&STEP::ObjectHelper<seam_curve,0>::Construct )
+,		SchemaEntry("security_classification",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("security_classification_level",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("serial_numbered_effectivity",&STEP::ObjectHelper<serial_numbered_effectivity,2>::Construct )
+,		SchemaEntry("shape_aspect_associativity",&STEP::ObjectHelper<shape_aspect_associativity,0>::Construct )
+,		SchemaEntry("shape_aspect_deriving_relationship",&STEP::ObjectHelper<shape_aspect_deriving_relationship,0>::Construct )
+,		SchemaEntry("shape_definition_representation",&STEP::ObjectHelper<shape_definition_representation,0>::Construct )
+,		SchemaEntry("shape_dimension_representation",&STEP::ObjectHelper<shape_dimension_representation,0>::Construct )
+,		SchemaEntry("shape_feature_definition",&STEP::ObjectHelper<shape_feature_definition,0>::Construct )
+,		SchemaEntry("shape_representation_with_parameters",&STEP::ObjectHelper<shape_representation_with_parameters,0>::Construct )
+,		SchemaEntry("shell_based_surface_model",&STEP::ObjectHelper<shell_based_surface_model,1>::Construct )
+,		SchemaEntry("shell_based_wireframe_model",&STEP::ObjectHelper<shell_based_wireframe_model,1>::Construct )
+,		SchemaEntry("shell_based_wireframe_shape_representation",&STEP::ObjectHelper<shell_based_wireframe_shape_representation,0>::Construct )
+,		SchemaEntry("si_absorbed_dose_unit",&STEP::ObjectHelper<si_absorbed_dose_unit,0>::Construct )
+,		SchemaEntry("si_capacitance_unit",&STEP::ObjectHelper<si_capacitance_unit,0>::Construct )
+,		SchemaEntry("si_conductance_unit",&STEP::ObjectHelper<si_conductance_unit,0>::Construct )
+,		SchemaEntry("si_dose_equivalent_unit",&STEP::ObjectHelper<si_dose_equivalent_unit,0>::Construct )
+,		SchemaEntry("si_electric_charge_unit",&STEP::ObjectHelper<si_electric_charge_unit,0>::Construct )
+,		SchemaEntry("si_electric_potential_unit",&STEP::ObjectHelper<si_electric_potential_unit,0>::Construct )
+,		SchemaEntry("si_energy_unit",&STEP::ObjectHelper<si_energy_unit,0>::Construct )
+,		SchemaEntry("si_force_unit",&STEP::ObjectHelper<si_force_unit,0>::Construct )
+,		SchemaEntry("si_frequency_unit",&STEP::ObjectHelper<si_frequency_unit,0>::Construct )
+,		SchemaEntry("si_illuminance_unit",&STEP::ObjectHelper<si_illuminance_unit,0>::Construct )
+,		SchemaEntry("si_inductance_unit",&STEP::ObjectHelper<si_inductance_unit,0>::Construct )
+,		SchemaEntry("si_magnetic_flux_density_unit",&STEP::ObjectHelper<si_magnetic_flux_density_unit,0>::Construct )
+,		SchemaEntry("si_magnetic_flux_unit",&STEP::ObjectHelper<si_magnetic_flux_unit,0>::Construct )
+,		SchemaEntry("si_power_unit",&STEP::ObjectHelper<si_power_unit,0>::Construct )
+,		SchemaEntry("si_pressure_unit",&STEP::ObjectHelper<si_pressure_unit,0>::Construct )
+,		SchemaEntry("si_radioactivity_unit",&STEP::ObjectHelper<si_radioactivity_unit,0>::Construct )
+,		SchemaEntry("si_resistance_unit",&STEP::ObjectHelper<si_resistance_unit,0>::Construct )
+,		SchemaEntry("si_unit",&STEP::ObjectHelper<si_unit,2>::Construct )
+,		SchemaEntry("simple_boolean_expression",&STEP::ObjectHelper<simple_boolean_expression,0>::Construct )
+,		SchemaEntry("simple_numeric_expression",&STEP::ObjectHelper<simple_numeric_expression,0>::Construct )
+,		SchemaEntry("slash_expression",&STEP::ObjectHelper<slash_expression,0>::Construct )
+,		SchemaEntry("smeared_material_definition",&STEP::ObjectHelper<smeared_material_definition,0>::Construct )
+,		SchemaEntry("solid_angle_measure_with_unit",&STEP::ObjectHelper<solid_angle_measure_with_unit,0>::Construct )
+,		SchemaEntry("solid_angle_unit",&STEP::ObjectHelper<solid_angle_unit,0>::Construct )
+,		SchemaEntry("solid_curve_font",&STEP::ObjectHelper<solid_curve_font,0>::Construct )
+,		SchemaEntry("solid_replica",&STEP::ObjectHelper<solid_replica,2>::Construct )
+,		SchemaEntry("solid_with_chamfered_edges",&STEP::ObjectHelper<solid_with_chamfered_edges,0>::Construct )
+,		SchemaEntry("solid_with_angle_based_chamfer",&STEP::ObjectHelper<solid_with_angle_based_chamfer,3>::Construct )
+,		SchemaEntry("solid_with_shape_element_pattern",&STEP::ObjectHelper<solid_with_shape_element_pattern,1>::Construct )
+,		SchemaEntry("solid_with_circular_pattern",&STEP::ObjectHelper<solid_with_circular_pattern,4>::Construct )
+,		SchemaEntry("solid_with_depression",&STEP::ObjectHelper<solid_with_depression,1>::Construct )
+,		SchemaEntry("solid_with_pocket",&STEP::ObjectHelper<solid_with_pocket,2>::Construct )
+,		SchemaEntry("solid_with_circular_pocket",&STEP::ObjectHelper<solid_with_circular_pocket,1>::Construct )
+,		SchemaEntry("solid_with_protrusion",&STEP::ObjectHelper<solid_with_protrusion,2>::Construct )
+,		SchemaEntry("solid_with_circular_protrusion",&STEP::ObjectHelper<solid_with_circular_protrusion,1>::Construct )
+,		SchemaEntry("solid_with_hole",&STEP::ObjectHelper<solid_with_hole,0>::Construct )
+,		SchemaEntry("solid_with_stepped_round_hole",&STEP::ObjectHelper<solid_with_stepped_round_hole,1>::Construct )
+,		SchemaEntry("solid_with_conical_bottom_round_hole",&STEP::ObjectHelper<solid_with_conical_bottom_round_hole,2>::Construct )
+,		SchemaEntry("solid_with_constant_radius_edge_blend",&STEP::ObjectHelper<solid_with_constant_radius_edge_blend,1>::Construct )
+,		SchemaEntry("solid_with_slot",&STEP::ObjectHelper<solid_with_slot,2>::Construct )
+,		SchemaEntry("solid_with_curved_slot",&STEP::ObjectHelper<solid_with_curved_slot,1>::Construct )
+,		SchemaEntry("solid_with_double_offset_chamfer",&STEP::ObjectHelper<solid_with_double_offset_chamfer,2>::Construct )
+,		SchemaEntry("solid_with_flat_bottom_round_hole",&STEP::ObjectHelper<solid_with_flat_bottom_round_hole,1>::Construct )
+,		SchemaEntry("solid_with_general_pocket",&STEP::ObjectHelper<solid_with_general_pocket,2>::Construct )
+,		SchemaEntry("solid_with_general_protrusion",&STEP::ObjectHelper<solid_with_general_protrusion,2>::Construct )
+,		SchemaEntry("solid_with_groove",&STEP::ObjectHelper<solid_with_groove,5>::Construct )
+,		SchemaEntry("solid_with_incomplete_circular_pattern",&STEP::ObjectHelper<solid_with_incomplete_circular_pattern,1>::Construct )
+,		SchemaEntry("solid_with_rectangular_pattern",&STEP::ObjectHelper<solid_with_rectangular_pattern,4>::Construct )
+,		SchemaEntry("solid_with_incomplete_rectangular_pattern",&STEP::ObjectHelper<solid_with_incomplete_rectangular_pattern,0>::Construct )
+,		SchemaEntry("solid_with_rectangular_pocket",&STEP::ObjectHelper<solid_with_rectangular_pocket,3>::Construct )
+,		SchemaEntry("solid_with_rectangular_protrusion",&STEP::ObjectHelper<solid_with_rectangular_protrusion,3>::Construct )
+,		SchemaEntry("solid_with_single_offset_chamfer",&STEP::ObjectHelper<solid_with_single_offset_chamfer,1>::Construct )
+,		SchemaEntry("solid_with_spherical_bottom_round_hole",&STEP::ObjectHelper<solid_with_spherical_bottom_round_hole,1>::Construct )
+,		SchemaEntry("solid_with_stepped_round_hole_and_conical_transitions",&STEP::ObjectHelper<solid_with_stepped_round_hole_and_conical_transitions,1>::Construct )
+,		SchemaEntry("solid_with_straight_slot",&STEP::ObjectHelper<solid_with_straight_slot,1>::Construct )
+,		SchemaEntry("solid_with_tee_section_slot",&STEP::ObjectHelper<solid_with_tee_section_slot,2>::Construct )
+,		SchemaEntry("solid_with_through_depression",&STEP::ObjectHelper<solid_with_through_depression,1>::Construct )
+,		SchemaEntry("solid_with_trapezoidal_section_slot",&STEP::ObjectHelper<solid_with_trapezoidal_section_slot,2>::Construct )
+,		SchemaEntry("solid_with_variable_radius_edge_blend",&STEP::ObjectHelper<solid_with_variable_radius_edge_blend,3>::Construct )
+,		SchemaEntry("source_for_requirement",&STEP::ObjectHelper<source_for_requirement,1>::Construct )
+,		SchemaEntry("sourced_requirement",&STEP::ObjectHelper<sourced_requirement,1>::Construct )
+,		SchemaEntry("specification_definition",&STEP::ObjectHelper<specification_definition,0>::Construct )
+,		SchemaEntry("specified_higher_usage_occurrence",&STEP::ObjectHelper<specified_higher_usage_occurrence,2>::Construct )
+,		SchemaEntry("sphere",&STEP::ObjectHelper<sphere,2>::Construct )
+,		SchemaEntry("spherical_surface",&STEP::ObjectHelper<spherical_surface,1>::Construct )
+,		SchemaEntry("start_request",&STEP::ObjectHelper<start_request,1>::Construct )
+,		SchemaEntry("start_work",&STEP::ObjectHelper<start_work,1>::Construct )
+,		SchemaEntry("straightness_tolerance",&STEP::ObjectHelper<straightness_tolerance,0>::Construct )
+,		SchemaEntry("structured_dimension_callout",&STEP::ObjectHelper<structured_dimension_callout,0>::Construct )
+,		SchemaEntry("structured_text_composition",&STEP::ObjectHelper<structured_text_composition,0>::Construct )
+,		SchemaEntry("structured_text_representation",&STEP::ObjectHelper<structured_text_representation,0>::Construct )
+,		SchemaEntry("subedge",&STEP::ObjectHelper<subedge,1>::Construct )
+,		SchemaEntry("subface",&STEP::ObjectHelper<subface,1>::Construct )
+,		SchemaEntry("supplied_part_relationship",&STEP::ObjectHelper<supplied_part_relationship,0>::Construct )
+,		SchemaEntry("surface_condition_callout",&STEP::ObjectHelper<surface_condition_callout,0>::Construct )
+,		SchemaEntry("swept_surface",&STEP::ObjectHelper<swept_surface,1>::Construct )
+,		SchemaEntry("surface_of_linear_extrusion",&STEP::ObjectHelper<surface_of_linear_extrusion,1>::Construct )
+,		SchemaEntry("surface_of_revolution",&STEP::ObjectHelper<surface_of_revolution,1>::Construct )
+,		SchemaEntry("surface_patch",&STEP::ObjectHelper<surface_patch,5>::Construct )
+,		SchemaEntry("surface_profile_tolerance",&STEP::ObjectHelper<surface_profile_tolerance,0>::Construct )
+,		SchemaEntry("surface_rendering_properties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("surface_replica",&STEP::ObjectHelper<surface_replica,2>::Construct )
+,		SchemaEntry("surface_side_style",&STEP::ObjectHelper<surface_side_style,2>::Construct )
+,		SchemaEntry("surface_style_boundary",&STEP::ObjectHelper<surface_style_boundary,1>::Construct )
+,		SchemaEntry("surface_style_control_grid",&STEP::ObjectHelper<surface_style_control_grid,1>::Construct )
+,		SchemaEntry("surface_style_fill_area",&STEP::ObjectHelper<surface_style_fill_area,1>::Construct )
+,		SchemaEntry("surface_style_parameter_line",&STEP::ObjectHelper<surface_style_parameter_line,2>::Construct )
+,		SchemaEntry("surface_style_reflectance_ambient",&STEP::ObjectHelper<surface_style_reflectance_ambient,1>::Construct )
+,		SchemaEntry("surface_style_reflectance_ambient_diffuse",&STEP::ObjectHelper<surface_style_reflectance_ambient_diffuse,1>::Construct )
+,		SchemaEntry("surface_style_reflectance_ambient_diffuse_specular",&STEP::ObjectHelper<surface_style_reflectance_ambient_diffuse_specular,3>::Construct )
+,		SchemaEntry("surface_style_rendering",&STEP::ObjectHelper<surface_style_rendering,2>::Construct )
+,		SchemaEntry("surface_style_rendering_with_properties",&STEP::ObjectHelper<surface_style_rendering_with_properties,1>::Construct )
+,		SchemaEntry("surface_style_segmentation_curve",&STEP::ObjectHelper<surface_style_segmentation_curve,1>::Construct )
+,		SchemaEntry("surface_style_silhouette",&STEP::ObjectHelper<surface_style_silhouette,1>::Construct )
+,		SchemaEntry("surface_style_transparent",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("surface_style_usage",&STEP::ObjectHelper<surface_style_usage,2>::Construct )
+,		SchemaEntry("surface_texture_representation",&STEP::ObjectHelper<surface_texture_representation,0>::Construct )
+,		SchemaEntry("surfaced_open_shell",&STEP::ObjectHelper<surfaced_open_shell,0>::Construct )
+,		SchemaEntry("swept_disk_solid",&STEP::ObjectHelper<swept_disk_solid,5>::Construct )
+,		SchemaEntry("symbol",&STEP::ObjectHelper<symbol,0>::Construct )
+,		SchemaEntry("symbol_colour",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("symbol_representation_map",&STEP::ObjectHelper<symbol_representation_map,0>::Construct )
+,		SchemaEntry("symbol_style",&STEP::ObjectHelper<symbol_style,2>::Construct )
+,		SchemaEntry("symbol_target",&STEP::ObjectHelper<symbol_target,3>::Construct )
+,		SchemaEntry("symmetric_shape_aspect",&STEP::ObjectHelper<symmetric_shape_aspect,0>::Construct )
+,		SchemaEntry("symmetry_tolerance",&STEP::ObjectHelper<symmetry_tolerance,0>::Construct )
+,		SchemaEntry("table_representation_item",&STEP::ObjectHelper<table_representation_item,0>::Construct )
+,		SchemaEntry("tactile_appearance_representation",&STEP::ObjectHelper<tactile_appearance_representation,0>::Construct )
+,		SchemaEntry("tagged_text_format",&STEP::ObjectHelper<tagged_text_format,0>::Construct )
+,		SchemaEntry("tagged_text_item",&STEP::ObjectHelper<tagged_text_item,0>::Construct )
+,		SchemaEntry("tangent",&STEP::ObjectHelper<tangent,0>::Construct )
+,		SchemaEntry("text_font",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("text_font_family",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("text_font_in_family",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("text_literal_with_associated_curves",&STEP::ObjectHelper<text_literal_with_associated_curves,1>::Construct )
+,		SchemaEntry("text_literal_with_blanking_box",&STEP::ObjectHelper<text_literal_with_blanking_box,1>::Construct )
+,		SchemaEntry("text_literal_with_extent",&STEP::ObjectHelper<text_literal_with_extent,1>::Construct )
+,		SchemaEntry("text_string_representation",&STEP::ObjectHelper<text_string_representation,0>::Construct )
+,		SchemaEntry("text_style",&STEP::ObjectHelper<text_style,2>::Construct )
+,		SchemaEntry("text_style_for_defined_font",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("text_style_with_box_characteristics",&STEP::ObjectHelper<text_style_with_box_characteristics,1>::Construct )
+,		SchemaEntry("text_style_with_mirror",&STEP::ObjectHelper<text_style_with_mirror,1>::Construct )
+,		SchemaEntry("text_style_with_spacing",&STEP::ObjectHelper<text_style_with_spacing,1>::Construct )
+,		SchemaEntry("thermal_resistance_measure_with_unit",&STEP::ObjectHelper<thermal_resistance_measure_with_unit,0>::Construct )
+,		SchemaEntry("thermal_resistance_unit",&STEP::ObjectHelper<thermal_resistance_unit,0>::Construct )
+,		SchemaEntry("thermodynamic_temperature_measure_with_unit",&STEP::ObjectHelper<thermodynamic_temperature_measure_with_unit,0>::Construct )
+,		SchemaEntry("thermodynamic_temperature_unit",&STEP::ObjectHelper<thermodynamic_temperature_unit,0>::Construct )
+,		SchemaEntry("thickened_face_solid",&STEP::ObjectHelper<thickened_face_solid,3>::Construct )
+,		SchemaEntry("thickness_laminate_definition",&STEP::ObjectHelper<thickness_laminate_definition,0>::Construct )
+,		SchemaEntry("thickness_laminate_table",&STEP::ObjectHelper<thickness_laminate_table,0>::Construct )
+,		SchemaEntry("time_interval",&STEP::ObjectHelper<time_interval,3>::Construct )
+,		SchemaEntry("time_interval_based_effectivity",&STEP::ObjectHelper<time_interval_based_effectivity,1>::Construct )
+,		SchemaEntry("time_interval_relationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("time_interval_role",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("time_interval_with_bounds",&STEP::ObjectHelper<time_interval_with_bounds,3>::Construct )
+,		SchemaEntry("time_measure_with_unit",&STEP::ObjectHelper<time_measure_with_unit,0>::Construct )
+,		SchemaEntry("time_unit",&STEP::ObjectHelper<time_unit,0>::Construct )
+,		SchemaEntry("tolerance_value",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("tolerance_zone",&STEP::ObjectHelper<tolerance_zone,2>::Construct )
+,		SchemaEntry("tolerance_zone_form",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("torus",&STEP::ObjectHelper<torus,3>::Construct )
+,		SchemaEntry("total_runout_tolerance",&STEP::ObjectHelper<total_runout_tolerance,0>::Construct )
+,		SchemaEntry("track_blended_solid",&STEP::ObjectHelper<track_blended_solid,0>::Construct )
+,		SchemaEntry("track_blended_solid_with_end_conditions",&STEP::ObjectHelper<track_blended_solid_with_end_conditions,1>::Construct )
+,		SchemaEntry("trimmed_curve",&STEP::ObjectHelper<trimmed_curve,5>::Construct )
+,		SchemaEntry("two_direction_repeat_factor",&STEP::ObjectHelper<two_direction_repeat_factor,1>::Construct )
+,		SchemaEntry("type_qualifier",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("unary_generic_expression",&STEP::ObjectHelper<unary_generic_expression,1>::Construct )
+,		SchemaEntry("unary_numeric_expression",&STEP::ObjectHelper<unary_numeric_expression,0>::Construct )
+,		SchemaEntry("uncertainty_assigned_representation",&STEP::ObjectHelper<uncertainty_assigned_representation,1>::Construct )
+,		SchemaEntry("uncertainty_measure_with_unit",&STEP::ObjectHelper<uncertainty_measure_with_unit,2>::Construct )
+,		SchemaEntry("uniform_curve",&STEP::ObjectHelper<uniform_curve,0>::Construct )
+,		SchemaEntry("uniform_resource_identifier",&STEP::ObjectHelper<uniform_resource_identifier,0>::Construct )
+,		SchemaEntry("uniform_surface",&STEP::ObjectHelper<uniform_surface,0>::Construct )
+,		SchemaEntry("usage_association",&STEP::ObjectHelper<usage_association,0>::Construct )
+,		SchemaEntry("user_defined_curve_font",&STEP::ObjectHelper<user_defined_curve_font,0>::Construct )
+,		SchemaEntry("user_defined_marker",&STEP::ObjectHelper<user_defined_marker,0>::Construct )
+,		SchemaEntry("user_defined_terminator_symbol",&STEP::ObjectHelper<user_defined_terminator_symbol,0>::Construct )
+,		SchemaEntry("user_selected_shape_elements",&STEP::ObjectHelper<user_selected_shape_elements,0>::Construct )
+,		SchemaEntry("value_range",&STEP::ObjectHelper<value_range,0>::Construct )
+,		SchemaEntry("value_representation_item",&STEP::ObjectHelper<value_representation_item,1>::Construct )
+,		SchemaEntry("variable_semantics",&STEP::ObjectHelper<variable_semantics,0>::Construct )
+,		SchemaEntry("variational_representation_item",&STEP::ObjectHelper<variational_representation_item,0>::Construct )
+,		SchemaEntry("vector",&STEP::ObjectHelper<vector,2>::Construct )
+,		SchemaEntry("vector_style",&STEP::ObjectHelper<vector_style,0>::Construct )
+,		SchemaEntry("velocity_measure_with_unit",&STEP::ObjectHelper<velocity_measure_with_unit,0>::Construct )
+,		SchemaEntry("velocity_unit",&STEP::ObjectHelper<velocity_unit,0>::Construct )
+,		SchemaEntry("versioned_action_request",&STEP::ObjectHelper<NotImplemented,0>::Construct )
+,		SchemaEntry("vertex",&STEP::ObjectHelper<vertex,0>::Construct )
+,		SchemaEntry("vertex_loop",&STEP::ObjectHelper<vertex_loop,1>::Construct )
+,		SchemaEntry("vertex_point",&STEP::ObjectHelper<vertex_point,1>::Construct )
+,		SchemaEntry("vertex_shell",&STEP::ObjectHelper<vertex_shell,1>::Construct )
+,		SchemaEntry("view_volume",&STEP::ObjectHelper<view_volume,9>::Construct )
+,		SchemaEntry("visual_appearance_representation",&STEP::ObjectHelper<visual_appearance_representation,0>::Construct )
+,		SchemaEntry("volume_measure_with_unit",&STEP::ObjectHelper<volume_measure_with_unit,0>::Construct )
+,		SchemaEntry("volume_unit",&STEP::ObjectHelper<volume_unit,0>::Construct )
+,		SchemaEntry("week_of_year_and_day_date",&STEP::ObjectHelper<week_of_year_and_day_date,2>::Construct )
+,		SchemaEntry("wire_shell",&STEP::ObjectHelper<wire_shell,1>::Construct )
+,		SchemaEntry("year_month",&STEP::ObjectHelper<year_month,1>::Construct )
+
+	};
+}
+
+// -----------------------------------------------------------------------------------------------------------
+void StepFile::GetSchema(EXPRESS::ConversionSchema& out)
+{
+	out = EXPRESS::ConversionSchema(schema_raw);
+}
+
+namespace STEP {
+
+    // -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<NotImplemented>(const STEP::DB& db, const LIST& params, NotImplemented* in)
+{
+	return 0;
+}
+
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<measure_with_unit>(const DB& db, const LIST& params, measure_with_unit* in)
+{
+	size_t base = 0;
+	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to measure_with_unit"); }    do { // convert the 'value_component' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::measure_with_unit,2>::aux_is_derived[0]=true; break; }
+        try { GenericConvert( in->value_component, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to measure_with_unit to be a `measure_value`")); }
+    } while(0);
+    do { // convert the 'unit_component' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::measure_with_unit,2>::aux_is_derived[1]=true; break; }
+        try { GenericConvert( in->unit_component, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to measure_with_unit to be a `unit`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<absorbed_dose_measure_with_unit>(const DB& db, const LIST& params, absorbed_dose_measure_with_unit* in)
+{
+	size_t base = GenericFill(db,params,static_cast<measure_with_unit*>(in));
+	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to absorbed_dose_measure_with_unit"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<derived_unit>(const DB& db, const LIST& params, derived_unit* in)
+{
+	size_t base = 0;
+	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to derived_unit"); }    do { // convert the 'elements' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::derived_unit,1>::aux_is_derived[0]=true; break; }
+        try { GenericConvert( in->elements, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to derived_unit to be a `SET [1:?] OF derived_unit_element`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<absorbed_dose_unit>(const DB& db, const LIST& params, absorbed_dose_unit* in)
+{
+	size_t base = GenericFill(db,params,static_cast<derived_unit*>(in));
+	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to absorbed_dose_unit"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<abstract_variable>(const DB& db, const LIST& params, abstract_variable* in)
+{
+	size_t base = 0;
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<acceleration_measure_with_unit>(const DB& db, const LIST& params, acceleration_measure_with_unit* in)
+{
+	size_t base = GenericFill(db,params,static_cast<measure_with_unit*>(in));
+	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to acceleration_measure_with_unit"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<acceleration_unit>(const DB& db, const LIST& params, acceleration_unit* in)
+{
+	size_t base = GenericFill(db,params,static_cast<derived_unit*>(in));
+	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to acceleration_unit"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<action>(const DB& db, const LIST& params, action* in)
+{
+	size_t base = 0;
+	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to action"); }    do { // convert the 'name' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::action,3>::aux_is_derived[0]=true; break; }
+        try { GenericConvert( in->name, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to action to be a `label`")); }
+    } while(0);
+    do { // convert the 'description' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::action,3>::aux_is_derived[1]=true; break; }
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->description, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to action to be a `text`")); }
+    } while(0);
+    do { // convert the 'chosen_method' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::action,3>::aux_is_derived[2]=true; break; }
+        try { GenericConvert( in->chosen_method, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to action to be a `action_method`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<action_assignment>(const DB& db, const LIST& params, action_assignment* in)
+{
+	size_t base = 0;
+	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to action_assignment"); }    do { // convert the 'assigned_action' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::action_assignment,1>::aux_is_derived[0]=true; break; }
+        try { GenericConvert( in->assigned_action, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to action_assignment to be a `action`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<action_method>(const DB& db, const LIST& params, action_method* in)
+{
+	size_t base = 0;
+	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to action_method"); }    do { // convert the 'name' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::action_method,4>::aux_is_derived[0]=true; break; }
+        try { GenericConvert( in->name, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to action_method to be a `label`")); }
+    } while(0);
+    do { // convert the 'description' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::action_method,4>::aux_is_derived[1]=true; break; }
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->description, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to action_method to be a `text`")); }
+    } while(0);
+    do { // convert the 'consequence' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::action_method,4>::aux_is_derived[2]=true; break; }
+        try { GenericConvert( in->consequence, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to action_method to be a `text`")); }
+    } while(0);
+    do { // convert the 'purpose' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::action_method,4>::aux_is_derived[3]=true; break; }
+        try { GenericConvert( in->purpose, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to action_method to be a `text`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<action_method_assignment>(const DB& db, const LIST& params, action_method_assignment* in)
+{
+	size_t base = 0;
+	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to action_method_assignment"); }    do { // convert the 'assigned_action_method' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::action_method_assignment,2>::aux_is_derived[0]=true; break; }
+        try { GenericConvert( in->assigned_action_method, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to action_method_assignment to be a `action_method`")); }
+    } while(0);
+    do { // convert the 'role' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::action_method_assignment,2>::aux_is_derived[1]=true; break; }
+        try { GenericConvert( in->role, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to action_method_assignment to be a `action_method_role`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<action_method_relationship>(const DB& db, const LIST& params, action_method_relationship* in)
+{
+	size_t base = 0;
+	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to action_method_relationship"); }    do { // convert the 'name' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::action_method_relationship,4>::aux_is_derived[0]=true; break; }
+        try { GenericConvert( in->name, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to action_method_relationship to be a `label`")); }
+    } while(0);
+    do { // convert the 'description' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::action_method_relationship,4>::aux_is_derived[1]=true; break; }
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->description, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to action_method_relationship to be a `text`")); }
+    } while(0);
+    do { // convert the 'relating_method' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::action_method_relationship,4>::aux_is_derived[2]=true; break; }
+        try { GenericConvert( in->relating_method, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to action_method_relationship to be a `action_method`")); }
+    } while(0);
+    do { // convert the 'related_method' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::action_method_relationship,4>::aux_is_derived[3]=true; break; }
+        try { GenericConvert( in->related_method, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to action_method_relationship to be a `action_method`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<action_request_assignment>(const DB& db, const LIST& params, action_request_assignment* in)
+{
+	size_t base = 0;
+	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to action_request_assignment"); }    do { // convert the 'assigned_action_request' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::action_request_assignment,1>::aux_is_derived[0]=true; break; }
+        try { GenericConvert( in->assigned_action_request, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to action_request_assignment to be a `versioned_action_request`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<address>(const DB& db, const LIST& params, address* in)
+{
+	size_t base = 0;
+	if (params.GetSize() < 12) { throw STEP::TypeError("expected 12 arguments to address"); }    do { // convert the 'internal_location' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::address,12>::aux_is_derived[0]=true; break; }
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->internal_location, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to address to be a `label`")); }
+    } while(0);
+    do { // convert the 'street_number' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::address,12>::aux_is_derived[1]=true; break; }
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->street_number, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to address to be a `label`")); }
+    } while(0);
+    do { // convert the 'street' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::address,12>::aux_is_derived[2]=true; break; }
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->street, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to address to be a `label`")); }
+    } while(0);
+    do { // convert the 'postal_box' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::address,12>::aux_is_derived[3]=true; break; }
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->postal_box, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to address to be a `label`")); }
+    } while(0);
+    do { // convert the 'town' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::address,12>::aux_is_derived[4]=true; break; }
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->town, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to address to be a `label`")); }
+    } while(0);
+    do { // convert the 'region' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::address,12>::aux_is_derived[5]=true; break; }
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->region, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to address to be a `label`")); }
+    } while(0);
+    do { // convert the 'postal_code' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::address,12>::aux_is_derived[6]=true; break; }
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->postal_code, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to address to be a `label`")); }
+    } while(0);
+    do { // convert the 'country' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::address,12>::aux_is_derived[7]=true; break; }
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->country, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to address to be a `label`")); }
+    } while(0);
+    do { // convert the 'facsimile_number' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::address,12>::aux_is_derived[8]=true; break; }
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->facsimile_number, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 8 to address to be a `label`")); }
+    } while(0);
+    do { // convert the 'telephone_number' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::address,12>::aux_is_derived[9]=true; break; }
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->telephone_number, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 9 to address to be a `label`")); }
+    } while(0);
+    do { // convert the 'electronic_mail_address' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::address,12>::aux_is_derived[10]=true; break; }
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->electronic_mail_address, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 10 to address to be a `label`")); }
+    } while(0);
+    do { // convert the 'telex_number' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::address,12>::aux_is_derived[11]=true; break; }
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->telex_number, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 11 to address to be a `label`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<representation>(const DB& db, const LIST& params, representation* in)
+{
+	size_t base = 0;
+	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to representation"); }    do { // convert the 'name' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::representation,3>::aux_is_derived[0]=true; break; }
+        try { GenericConvert( in->name, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to representation to be a `label`")); }
+    } while(0);
+    do { // convert the 'items' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::representation,3>::aux_is_derived[1]=true; break; }
+        try { GenericConvert( in->items, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to representation to be a `SET [1:?] OF representation_item`")); }
+    } while(0);
+    do { // convert the 'context_of_items' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::representation,3>::aux_is_derived[2]=true; break; }
+        try { GenericConvert( in->context_of_items, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to representation to be a `representation_context`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<shape_representation>(const DB& db, const LIST& params, shape_representation* in)
+{
+	size_t base = GenericFill(db,params,static_cast<representation*>(in));
+	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to shape_representation"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<advanced_brep_shape_representation>(const DB& db, const LIST& params, advanced_brep_shape_representation* in)
+{
+	size_t base = GenericFill(db,params,static_cast<shape_representation*>(in));
+	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to advanced_brep_shape_representation"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<face_surface>(const DB& db, const LIST& params, face_surface* in)
+{
+	size_t base = 0;
+	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to face_surface"); }    do { // convert the 'face_geometry' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::face_surface,2>::aux_is_derived[0]=true; break; }
+        try { GenericConvert( in->face_geometry, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to face_surface to be a `surface`")); }
+    } while(0);
+    do { // convert the 'same_sense' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::face_surface,2>::aux_is_derived[1]=true; break; }
+        try { GenericConvert( in->same_sense, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to face_surface to be a `BOOLEAN`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<advanced_face>(const DB& db, const LIST& params, advanced_face* in)
+{
+	size_t base = GenericFill(db,params,static_cast<face_surface*>(in));
+	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to advanced_face"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<amount_of_substance_measure_with_unit>(const DB& db, const LIST& params, amount_of_substance_measure_with_unit* in)
+{
+	size_t base = GenericFill(db,params,static_cast<measure_with_unit*>(in));
+	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to amount_of_substance_measure_with_unit"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<named_unit>(const DB& db, const LIST& params, named_unit* in)
+{
+	size_t base = 0;
+	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to named_unit"); }    do { // convert the 'dimensions' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::named_unit,1>::aux_is_derived[0]=true; break; }
+        try { GenericConvert( in->dimensions, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to named_unit to be a `dimensional_exponents`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<amount_of_substance_unit>(const DB& db, const LIST& params, amount_of_substance_unit* in)
+{
+	size_t base = GenericFill(db,params,static_cast<named_unit*>(in));
+	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to amount_of_substance_unit"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<angle_direction_reference>(const DB& db, const LIST& params, angle_direction_reference* in)
+{
+	size_t base = 0;
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<representation_item>(const DB& db, const LIST& params, representation_item* in)
+{
+	size_t base = 0;
+	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to representation_item"); }    do { // convert the 'name' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::representation_item,1>::aux_is_derived[0]=true; break; }
+        try { GenericConvert( in->name, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to representation_item to be a `label`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<geometric_representation_item>(const DB& db, const LIST& params, geometric_representation_item* in)
+{
+	size_t base = GenericFill(db,params,static_cast<representation_item*>(in));
+	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to geometric_representation_item"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<draughting_callout>(const DB& db, const LIST& params, draughting_callout* in)
+{
+	size_t base = GenericFill(db,params,static_cast<geometric_representation_item*>(in));
+	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to draughting_callout"); }    do { // convert the 'contents' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::draughting_callout,1>::aux_is_derived[0]=true; break; }
+        try { GenericConvert( in->contents, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to draughting_callout to be a `SET [1:?] OF draughting_callout_element`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<dimension_curve_directed_callout>(const DB& db, const LIST& params, dimension_curve_directed_callout* in)
+{
+	size_t base = GenericFill(db,params,static_cast<draughting_callout*>(in));
+	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to dimension_curve_directed_callout"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<angular_dimension>(const DB& db, const LIST& params, angular_dimension* in)
+{
+	size_t base = GenericFill(db,params,static_cast<dimension_curve_directed_callout*>(in));
+	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to angular_dimension"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<shape_aspect_relationship>(const DB& db, const LIST& params, shape_aspect_relationship* in)
+{
+	size_t base = 0;
+	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to shape_aspect_relationship"); }    do { // convert the 'name' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::shape_aspect_relationship,4>::aux_is_derived[0]=true; break; }
+        try { GenericConvert( in->name, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to shape_aspect_relationship to be a `label`")); }
+    } while(0);
+    do { // convert the 'description' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::shape_aspect_relationship,4>::aux_is_derived[1]=true; break; }
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->description, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to shape_aspect_relationship to be a `text`")); }
+    } while(0);
+    do { // convert the 'relating_shape_aspect' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::shape_aspect_relationship,4>::aux_is_derived[2]=true; break; }
+        try { GenericConvert( in->relating_shape_aspect, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to shape_aspect_relationship to be a `shape_aspect`")); }
+    } while(0);
+    do { // convert the 'related_shape_aspect' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::shape_aspect_relationship,4>::aux_is_derived[3]=true; break; }
+        try { GenericConvert( in->related_shape_aspect, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to shape_aspect_relationship to be a `shape_aspect`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<dimensional_location>(const DB& db, const LIST& params, dimensional_location* in)
+{
+	size_t base = GenericFill(db,params,static_cast<shape_aspect_relationship*>(in));
+	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to dimensional_location"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<angular_location>(const DB& db, const LIST& params, angular_location* in)
+{
+	size_t base = GenericFill(db,params,static_cast<dimensional_location*>(in));
+	if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to angular_location"); }    do { // convert the 'angle_selection' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert( in->angle_selection, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to angular_location to be a `angle_relator`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<dimensional_size>(const DB& db, const LIST& params, dimensional_size* in)
+{
+	size_t base = 0;
+	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to dimensional_size"); }    do { // convert the 'applies_to' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::dimensional_size,2>::aux_is_derived[0]=true; break; }
+        try { GenericConvert( in->applies_to, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to dimensional_size to be a `shape_aspect`")); }
+    } while(0);
+    do { // convert the 'name' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::dimensional_size,2>::aux_is_derived[1]=true; break; }
+        try { GenericConvert( in->name, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to dimensional_size to be a `label`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<angular_size>(const DB& db, const LIST& params, angular_size* in)
+{
+	size_t base = GenericFill(db,params,static_cast<dimensional_size*>(in));
+	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to angular_size"); }    do { // convert the 'angle_selection' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert( in->angle_selection, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to angular_size to be a `angle_relator`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<geometric_tolerance>(const DB& db, const LIST& params, geometric_tolerance* in)
+{
+	size_t base = 0;
+	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to geometric_tolerance"); }    do { // convert the 'name' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::geometric_tolerance,4>::aux_is_derived[0]=true; break; }
+        try { GenericConvert( in->name, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to geometric_tolerance to be a `label`")); }
+    } while(0);
+    do { // convert the 'description' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::geometric_tolerance,4>::aux_is_derived[1]=true; break; }
+        try { GenericConvert( in->description, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to geometric_tolerance to be a `text`")); }
+    } while(0);
+    do { // convert the 'magnitude' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::geometric_tolerance,4>::aux_is_derived[2]=true; break; }
+        try { GenericConvert( in->magnitude, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to geometric_tolerance to be a `measure_with_unit`")); }
+    } while(0);
+    do { // convert the 'toleranced_shape_aspect' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::geometric_tolerance,4>::aux_is_derived[3]=true; break; }
+        try { GenericConvert( in->toleranced_shape_aspect, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to geometric_tolerance to be a `shape_aspect`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<geometric_tolerance_with_datum_reference>(const DB& db, const LIST& params, geometric_tolerance_with_datum_reference* in)
+{
+	size_t base = GenericFill(db,params,static_cast<geometric_tolerance*>(in));
+	if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to geometric_tolerance_with_datum_reference"); }    do { // convert the 'datum_system' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::geometric_tolerance_with_datum_reference,1>::aux_is_derived[0]=true; break; }
+        try { GenericConvert( in->datum_system, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to geometric_tolerance_with_datum_reference to be a `SET [1:?] OF datum_reference`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<angularity_tolerance>(const DB& db, const LIST& params, angularity_tolerance* in)
+{
+	size_t base = GenericFill(db,params,static_cast<geometric_tolerance_with_datum_reference*>(in));
+	if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to angularity_tolerance"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<styled_item>(const DB& db, const LIST& params, styled_item* in)
+{
+	size_t base = GenericFill(db,params,static_cast<representation_item*>(in));
+	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to styled_item"); }    do { // convert the 'styles' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::styled_item,2>::aux_is_derived[0]=true; break; }
+        try { GenericConvert( in->styles, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to styled_item to be a `SET [1:?] OF presentation_style_assignment`")); }
+    } while(0);
+    do { // convert the 'item' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::styled_item,2>::aux_is_derived[1]=true; break; }
+        try { GenericConvert( in->item, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to styled_item to be a `representation_item`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<annotation_occurrence>(const DB& db, const LIST& params, annotation_occurrence* in)
+{
+	size_t base = GenericFill(db,params,static_cast<styled_item*>(in));
+	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to annotation_occurrence"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<annotation_curve_occurrence>(const DB& db, const LIST& params, annotation_curve_occurrence* in)
+{
+	size_t base = GenericFill(db,params,static_cast<annotation_occurrence*>(in));
+	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to annotation_curve_occurrence"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<annotation_fill_area>(const DB& db, const LIST& params, annotation_fill_area* in)
+{
+	size_t base = GenericFill(db,params,static_cast<geometric_representation_item*>(in));
+	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to annotation_fill_area"); }    do { // convert the 'boundaries' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert( in->boundaries, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to annotation_fill_area to be a `SET [1:?] OF curve`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<annotation_fill_area_occurrence>(const DB& db, const LIST& params, annotation_fill_area_occurrence* in)
+{
+	size_t base = GenericFill(db,params,static_cast<annotation_occurrence*>(in));
+	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to annotation_fill_area_occurrence"); }    do { // convert the 'fill_style_target' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert( in->fill_style_target, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to annotation_fill_area_occurrence to be a `point`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<annotation_occurrence_relationship>(const DB& db, const LIST& params, annotation_occurrence_relationship* in)
+{
+	size_t base = 0;
+	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to annotation_occurrence_relationship"); }    do { // convert the 'name' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::annotation_occurrence_relationship,4>::aux_is_derived[0]=true; break; }
+        try { GenericConvert( in->name, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to annotation_occurrence_relationship to be a `label`")); }
+    } while(0);
+    do { // convert the 'description' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::annotation_occurrence_relationship,4>::aux_is_derived[1]=true; break; }
+        try { GenericConvert( in->description, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to annotation_occurrence_relationship to be a `text`")); }
+    } while(0);
+    do { // convert the 'relating_annotation_occurrence' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::annotation_occurrence_relationship,4>::aux_is_derived[2]=true; break; }
+        try { GenericConvert( in->relating_annotation_occurrence, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to annotation_occurrence_relationship to be a `annotation_occurrence`")); }
+    } while(0);
+    do { // convert the 'related_annotation_occurrence' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::annotation_occurrence_relationship,4>::aux_is_derived[3]=true; break; }
+        try { GenericConvert( in->related_annotation_occurrence, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to annotation_occurrence_relationship to be a `annotation_occurrence`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<annotation_occurrence_associativity>(const DB& db, const LIST& params, annotation_occurrence_associativity* in)
+{
+	size_t base = GenericFill(db,params,static_cast<annotation_occurrence_relationship*>(in));
+	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to annotation_occurrence_associativity"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<annotation_plane>(const DB& db, const LIST& params, annotation_plane* in)
+{
+	size_t base = 0;
+	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to annotation_plane"); }    do { // convert the 'elements' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert( in->elements, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to annotation_plane to be a `SET [1:?] OF annotation_plane_element`")); }
+    } while(0);
+	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<annotation_symbol_occurrence>(const DB& db, const LIST& params, annotation_symbol_occurrence* in)
+{
+	size_t base = GenericFill(db,params,static_cast<annotation_occurrence*>(in));
+	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to annotation_symbol_occurrence"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<annotation_subfigure_occurrence>(const DB& db, const LIST& params, annotation_subfigure_occurrence* in)
+{
+	size_t base = GenericFill(db,params,static_cast<annotation_symbol_occurrence*>(in));
+	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to annotation_subfigure_occurrence"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<mapped_item>(const DB& db, const LIST& params, mapped_item* in)
+{
+	size_t base = GenericFill(db,params,static_cast<representation_item*>(in));
+	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to mapped_item"); }    do { // convert the 'mapping_source' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::mapped_item,2>::aux_is_derived[0]=true; break; }
+        try { GenericConvert( in->mapping_source, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to mapped_item to be a `representation_map`")); }
+    } while(0);
+    do { // convert the 'mapping_target' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::mapped_item,2>::aux_is_derived[1]=true; break; }
+        try { GenericConvert( in->mapping_target, arg, db ); break; } 
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to mapped_item to be a `representation_item`")); }
+    } while(0);
+	return base;
+}
+
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<annotation_symbol>(const DB& db, const LIST& params, annotation_symbol* in)
+{
+    size_t base = GenericFill(db, params, static_cast<mapped_item*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to annotation_symbol"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<annotation_text>(const DB& db, const LIST& params, annotation_text* in)
+{
+    size_t base = GenericFill(db, params, static_cast<mapped_item*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to annotation_text"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<annotation_text_character>(const DB& db, const LIST& params, annotation_text_character* in)
+{
+    size_t base = GenericFill(db, params, static_cast<mapped_item*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to annotation_text_character"); }    do { // convert the 'alignment' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->alignment, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to annotation_text_character to be a `text_alignment`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<annotation_text_occurrence>(const DB& db, const LIST& params, annotation_text_occurrence* in)
+{
+    size_t base = GenericFill(db, params, static_cast<annotation_occurrence*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to annotation_text_occurrence"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<shape_aspect>(const DB& db, const LIST& params, shape_aspect* in)
+{
+    size_t base = 0;
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to shape_aspect"); }    do { // convert the 'name' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::shape_aspect, 4>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->name, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to shape_aspect to be a `label`")); }
+    } while (0);
+    do { // convert the 'description' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::shape_aspect, 4>::aux_is_derived[1] = true; break; }
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert(in->description, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to shape_aspect to be a `text`")); }
+    } while (0);
+    do { // convert the 'of_shape' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::shape_aspect, 4>::aux_is_derived[2] = true; break; }
+        try { GenericConvert(in->of_shape, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to shape_aspect to be a `product_definition_shape`")); }
+    } while (0);
+    do { // convert the 'product_definitional' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::shape_aspect, 4>::aux_is_derived[3] = true; break; }
+        try { GenericConvert(in->product_definitional, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to shape_aspect to be a `LOGICAL`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<derived_shape_aspect>(const DB& db, const LIST& params, derived_shape_aspect* in)
+{
+    size_t base = GenericFill(db, params, static_cast<shape_aspect*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to derived_shape_aspect"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<apex>(const DB& db, const LIST& params, apex* in)
+{
+    size_t base = GenericFill(db, params, static_cast<derived_shape_aspect*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to apex"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<application_context_element>(const DB& db, const LIST& params, application_context_element* in)
+{
+    size_t base = 0;
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to application_context_element"); }    do { // convert the 'name' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::application_context_element, 2>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->name, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to application_context_element to be a `label`")); }
+    } while (0);
+    do { // convert the 'frame_of_reference' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::application_context_element, 2>::aux_is_derived[1] = true; break; }
+        try { GenericConvert(in->frame_of_reference, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to application_context_element to be a `application_context`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<applied_action_assignment>(const DB& db, const LIST& params, applied_action_assignment* in)
+{
+    size_t base = GenericFill(db, params, static_cast<action_assignment*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to applied_action_assignment"); }    do { // convert the 'items' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::applied_action_assignment, 1>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->items, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to applied_action_assignment to be a `SET [1:?] OF action_items`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<applied_action_method_assignment>(const DB& db, const LIST& params, applied_action_method_assignment* in)
+{
+    size_t base = GenericFill(db, params, static_cast<action_method_assignment*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to applied_action_method_assignment"); }    do { // convert the 'items' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->items, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to applied_action_method_assignment to be a `SET [1:?] OF action_method_items`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<applied_action_request_assignment>(const DB& db, const LIST& params, applied_action_request_assignment* in)
+{
+    size_t base = GenericFill(db, params, static_cast<action_request_assignment*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to applied_action_request_assignment"); }    do { // convert the 'items' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->items, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to applied_action_request_assignment to be a `SET [1:?] OF action_request_item`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<approval_assignment>(const DB& db, const LIST& params, approval_assignment* in)
+{
+    size_t base = 0;
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to approval_assignment"); }    do { // convert the 'assigned_approval' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::approval_assignment, 1>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->assigned_approval, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to approval_assignment to be a `approval`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<applied_approval_assignment>(const DB& db, const LIST& params, applied_approval_assignment* in)
+{
+    size_t base = GenericFill(db, params, static_cast<approval_assignment*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to applied_approval_assignment"); }    do { // convert the 'items' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->items, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to applied_approval_assignment to be a `SET [1:?] OF approval_item`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<attribute_classification_assignment>(const DB& db, const LIST& params, attribute_classification_assignment* in)
+{
+    size_t base = 0;
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to attribute_classification_assignment"); }    do { // convert the 'assigned_class' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::attribute_classification_assignment, 3>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->assigned_class, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to attribute_classification_assignment to be a `group`")); }
+    } while (0);
+    do { // convert the 'attribute_name' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::attribute_classification_assignment, 3>::aux_is_derived[1] = true; break; }
+        try { GenericConvert(in->attribute_name, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to attribute_classification_assignment to be a `label`")); }
+    } while (0);
+    do { // convert the 'role' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::attribute_classification_assignment, 3>::aux_is_derived[2] = true; break; }
+        try { GenericConvert(in->role, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to attribute_classification_assignment to be a `classification_role`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<applied_attribute_classification_assignment>(const DB& db, const LIST& params, applied_attribute_classification_assignment* in)
+{
+    size_t base = GenericFill(db, params, static_cast<attribute_classification_assignment*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to applied_attribute_classification_assignment"); }    do { // convert the 'items' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->items, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to applied_attribute_classification_assignment to be a `SET [1:?] OF attribute_classification_item`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<certification_assignment>(const DB& db, const LIST& params, certification_assignment* in)
+{
+    size_t base = 0;
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to certification_assignment"); }    do { // convert the 'assigned_certification' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::certification_assignment, 1>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->assigned_certification, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to certification_assignment to be a `certification`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<applied_certification_assignment>(const DB& db, const LIST& params, applied_certification_assignment* in)
+{
+    size_t base = GenericFill(db, params, static_cast<certification_assignment*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to applied_certification_assignment"); }    do { // convert the 'items' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->items, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to applied_certification_assignment to be a `SET [1:?] OF certification_item`")); }
+    } while (0);
+    return base;
+}
+
+} // ! STEP
+} // ! Assimp
+
+#endif

code/Importer/StepFile/StepFileGen2.cpp

@@ -0,0 +1,3067 @@
+/*
+Open Asset Import Library (ASSIMP)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2010, ASSIMP Development Team
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the ASSIMP team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the ASSIMP Development Team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+#include "code/Importer/StepFile/StepReaderGen.h"
+
+namespace Assimp {
+using namespace StepFile;
+namespace STEP {
+
+    // -----------------------------------------------------------------------------------------------------------
+    template <> size_t GenericFill<classification_assignment>(const DB& db, const LIST& params, classification_assignment* in)
+    {
+        size_t base = 0;
+        if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to classification_assignment"); }    do { // convert the 'assigned_class' argument
+            std::shared_ptr<const DataType> arg = params[base++];
+            if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::classification_assignment, 2>::aux_is_derived[0] = true; break; }
+            try { GenericConvert(in->assigned_class, arg, db); break; }
+            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to classification_assignment to be a `group`")); }
+        } while (0);
+        do { // convert the 'role' argument
+            std::shared_ptr<const DataType> arg = params[base++];
+            if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::classification_assignment, 2>::aux_is_derived[1] = true; break; }
+            try { GenericConvert(in->role, arg, db); break; }
+            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to classification_assignment to be a `classification_role`")); }
+        } while (0);
+        return base;
+    }
+    // -----------------------------------------------------------------------------------------------------------
+    template <> size_t GenericFill<applied_classification_assignment>(const DB& db, const LIST& params, applied_classification_assignment* in)
+    {
+        size_t base = GenericFill(db, params, static_cast<classification_assignment*>(in));
+        if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to applied_classification_assignment"); }    do { // convert the 'items' argument
+            std::shared_ptr<const DataType> arg = params[base++];
+            try { GenericConvert(in->items, arg, db); break; }
+            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to applied_classification_assignment to be a `SET [1:?] OF classification_item`")); }
+        } while (0);
+        return base;
+    }
+    // -----------------------------------------------------------------------------------------------------------
+    template <> size_t GenericFill<contract_assignment>(const DB& db, const LIST& params, contract_assignment* in)
+    {
+        size_t base = 0;
+        if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to contract_assignment"); }    do { // convert the 'assigned_contract' argument
+            std::shared_ptr<const DataType> arg = params[base++];
+            if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::contract_assignment, 1>::aux_is_derived[0] = true; break; }
+            try { GenericConvert(in->assigned_contract, arg, db); break; }
+            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to contract_assignment to be a `contract`")); }
+        } while (0);
+        return base;
+    }
+    // -----------------------------------------------------------------------------------------------------------
+    template <> size_t GenericFill<applied_contract_assignment>(const DB& db, const LIST& params, applied_contract_assignment* in)
+    {
+        size_t base = GenericFill(db, params, static_cast<contract_assignment*>(in));
+        if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to applied_contract_assignment"); }    do { // convert the 'items' argument
+            std::shared_ptr<const DataType> arg = params[base++];
+            try { GenericConvert(in->items, arg, db); break; }
+            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to applied_contract_assignment to be a `SET [1:?] OF contract_item`")); }
+        } while (0);
+        return base;
+    }
+    // -----------------------------------------------------------------------------------------------------------
+    template <> size_t GenericFill<date_and_time_assignment>(const DB& db, const LIST& params, date_and_time_assignment* in)
+    {
+        size_t base = 0;
+        if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to date_and_time_assignment"); }    do { // convert the 'assigned_date_and_time' argument
+            std::shared_ptr<const DataType> arg = params[base++];
+            if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::date_and_time_assignment, 2>::aux_is_derived[0] = true; break; }
+            try { GenericConvert(in->assigned_date_and_time, arg, db); break; }
+            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to date_and_time_assignment to be a `date_and_time`")); }
+        } while (0);
+        do { // convert the 'role' argument
+            std::shared_ptr<const DataType> arg = params[base++];
+            if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::date_and_time_assignment, 2>::aux_is_derived[1] = true; break; }
+            try { GenericConvert(in->role, arg, db); break; }
+            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to date_and_time_assignment to be a `date_time_role`")); }
+        } while (0);
+        return base;
+    }
+    // -----------------------------------------------------------------------------------------------------------
+    template <> size_t GenericFill<applied_date_and_time_assignment>(const DB& db, const LIST& params, applied_date_and_time_assignment* in)
+    {
+        size_t base = GenericFill(db, params, static_cast<date_and_time_assignment*>(in));
+        if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to applied_date_and_time_assignment"); }    do { // convert the 'items' argument
+            std::shared_ptr<const DataType> arg = params[base++];
+            try { GenericConvert(in->items, arg, db); break; }
+            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to applied_date_and_time_assignment to be a `SET [1:?] OF date_and_time_item`")); }
+        } while (0);
+        return base;
+    }
+    // -----------------------------------------------------------------------------------------------------------
+    template <> size_t GenericFill<date_assignment>(const DB& db, const LIST& params, date_assignment* in)
+    {
+        size_t base = 0;
+        if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to date_assignment"); }    do { // convert the 'assigned_date' argument
+            std::shared_ptr<const DataType> arg = params[base++];
+            if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::date_assignment, 2>::aux_is_derived[0] = true; break; }
+            try { GenericConvert(in->assigned_date, arg, db); break; }
+            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to date_assignment to be a `date`")); }
+        } while (0);
+        do { // convert the 'role' argument
+            std::shared_ptr<const DataType> arg = params[base++];
+            if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::date_assignment, 2>::aux_is_derived[1] = true; break; }
+            try { GenericConvert(in->role, arg, db); break; }
+            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to date_assignment to be a `date_role`")); }
+        } while (0);
+        return base;
+    }
+    // -----------------------------------------------------------------------------------------------------------
+    template <> size_t GenericFill<applied_date_assignment>(const DB& db, const LIST& params, applied_date_assignment* in)
+    {
+        size_t base = GenericFill(db, params, static_cast<date_assignment*>(in));
+        if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to applied_date_assignment"); }    do { // convert the 'items' argument
+            std::shared_ptr<const DataType> arg = params[base++];
+            try { GenericConvert(in->items, arg, db); break; }
+            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to applied_date_assignment to be a `SET [1:?] OF date_item`")); }
+        } while (0);
+        return base;
+    }
+    // -----------------------------------------------------------------------------------------------------------
+    template <> size_t GenericFill<document_reference>(const DB& db, const LIST& params, document_reference* in)
+    {
+        size_t base = 0;
+        if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to document_reference"); }    do { // convert the 'assigned_document' argument
+            std::shared_ptr<const DataType> arg = params[base++];
+            if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::document_reference, 2>::aux_is_derived[0] = true; break; }
+            try { GenericConvert(in->assigned_document, arg, db); break; }
+            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to document_reference to be a `document`")); }
+        } while (0);
+        do { // convert the 'source' argument
+            std::shared_ptr<const DataType> arg = params[base++];
+            if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::document_reference, 2>::aux_is_derived[1] = true; break; }
+            try { GenericConvert(in->source, arg, db); break; }
+            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to document_reference to be a `label`")); }
+        } while (0);
+        return base;
+    }
+    // -----------------------------------------------------------------------------------------------------------
+    template <> size_t GenericFill<applied_document_reference>(const DB& db, const LIST& params, applied_document_reference* in)
+    {
+        size_t base = GenericFill(db, params, static_cast<document_reference*>(in));
+        if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to applied_document_reference"); }    do { // convert the 'items' argument
+            std::shared_ptr<const DataType> arg = params[base++];
+            try { GenericConvert(in->items, arg, db); break; }
+            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to applied_document_reference to be a `SET [1:?] OF document_reference_item`")); }
+        } while (0);
+        return base;
+    }
+    // -----------------------------------------------------------------------------------------------------------
+    template <> size_t GenericFill<document_usage_constraint_assignment>(const DB& db, const LIST& params, document_usage_constraint_assignment* in)
+    {
+        size_t base = 0;
+        if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to document_usage_constraint_assignment"); }    do { // convert the 'assigned_document_usage' argument
+            std::shared_ptr<const DataType> arg = params[base++];
+            if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::document_usage_constraint_assignment, 2>::aux_is_derived[0] = true; break; }
+            try { GenericConvert(in->assigned_document_usage, arg, db); break; }
+            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to document_usage_constraint_assignment to be a `document_usage_constraint`")); }
+        } while (0);
+        do { // convert the 'role' argument
+            std::shared_ptr<const DataType> arg = params[base++];
+            if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::document_usage_constraint_assignment, 2>::aux_is_derived[1] = true; break; }
+            try { GenericConvert(in->role, arg, db); break; }
+            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to document_usage_constraint_assignment to be a `document_usage_role`")); }
+        } while (0);
+        return base;
+    }
+    // -----------------------------------------------------------------------------------------------------------
+    template <> size_t GenericFill<applied_document_usage_constraint_assignment>(const DB& db, const LIST& params, applied_document_usage_constraint_assignment* in)
+    {
+        size_t base = GenericFill(db, params, static_cast<document_usage_constraint_assignment*>(in));
+        if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to applied_document_usage_constraint_assignment"); }    do { // convert the 'items' argument
+            std::shared_ptr<const DataType> arg = params[base++];
+            try { GenericConvert(in->items, arg, db); break; }
+            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to applied_document_usage_constraint_assignment to be a `SET [1:?] OF document_reference_item`")); }
+        } while (0);
+        return base;
+    }
+    // -----------------------------------------------------------------------------------------------------------
+    template <> size_t GenericFill<effectivity_assignment>(const DB& db, const LIST& params, effectivity_assignment* in)
+    {
+        size_t base = 0;
+        if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to effectivity_assignment"); }    do { // convert the 'assigned_effectivity' argument
+            std::shared_ptr<const DataType> arg = params[base++];
+            if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::effectivity_assignment, 1>::aux_is_derived[0] = true; break; }
+            try { GenericConvert(in->assigned_effectivity, arg, db); break; }
+            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to effectivity_assignment to be a `effectivity`")); }
+        } while (0);
+        return base;
+    }
+    // -----------------------------------------------------------------------------------------------------------
+    template <> size_t GenericFill<applied_effectivity_assignment>(const DB& db, const LIST& params, applied_effectivity_assignment* in)
+    {
+        size_t base = GenericFill(db, params, static_cast<effectivity_assignment*>(in));
+        if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to applied_effectivity_assignment"); }    do { // convert the 'items' argument
+            std::shared_ptr<const DataType> arg = params[base++];
+            try { GenericConvert(in->items, arg, db); break; }
+            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to applied_effectivity_assignment to be a `SET [1:?] OF effectivity_item`")); }
+        } while (0);
+        return base;
+    }
+    // -----------------------------------------------------------------------------------------------------------
+    template <> size_t GenericFill<event_occurrence_assignment>(const DB& db, const LIST& params, event_occurrence_assignment* in)
+    {
+        size_t base = 0;
+        if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to event_occurrence_assignment"); }    do { // convert the 'assigned_event_occurrence' argument
+            std::shared_ptr<const DataType> arg = params[base++];
+            if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::event_occurrence_assignment, 2>::aux_is_derived[0] = true; break; }
+            try { GenericConvert(in->assigned_event_occurrence, arg, db); break; }
+            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to event_occurrence_assignment to be a `event_occurrence`")); }
+        } while (0);
+        do { // convert the 'role' argument
+            std::shared_ptr<const DataType> arg = params[base++];
+            if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::event_occurrence_assignment, 2>::aux_is_derived[1] = true; break; }
+            try { GenericConvert(in->role, arg, db); break; }
+            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to event_occurrence_assignment to be a `event_occurrence_role`")); }
+        } while (0);
+        return base;
+    }
+    // -----------------------------------------------------------------------------------------------------------
+    template <> size_t GenericFill<applied_event_occurrence_assignment>(const DB& db, const LIST& params, applied_event_occurrence_assignment* in)
+    {
+        size_t base = GenericFill(db, params, static_cast<event_occurrence_assignment*>(in));
+        if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to applied_event_occurrence_assignment"); }    do { // convert the 'items' argument
+            std::shared_ptr<const DataType> arg = params[base++];
+            try { GenericConvert(in->items, arg, db); break; }
+            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to applied_event_occurrence_assignment to be a `SET [1:?] OF event_occurrence_item`")); }
+        } while (0);
+        return base;
+    }
+    // -----------------------------------------------------------------------------------------------------------
+    template <> size_t GenericFill<identification_assignment>(const DB& db, const LIST& params, identification_assignment* in)
+    {
+        size_t base = 0;
+        if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to identification_assignment"); }    do { // convert the 'assigned_id' argument
+            std::shared_ptr<const DataType> arg = params[base++];
+            if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::identification_assignment, 2>::aux_is_derived[0] = true; break; }
+            try { GenericConvert(in->assigned_id, arg, db); break; }
+            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to identification_assignment to be a `identifier`")); }
+        } while (0);
+        do { // convert the 'role' argument
+            std::shared_ptr<const DataType> arg = params[base++];
+            if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::identification_assignment, 2>::aux_is_derived[1] = true; break; }
+            try { GenericConvert(in->role, arg, db); break; }
+            catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to identification_assignment to be a `identification_role`")); }
+        } while (0);
+        return base;
+    }
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<external_identification_assignment>(const DB& db, const LIST& params, external_identification_assignment* in)
+{
+    size_t base = GenericFill(db, params, static_cast<identification_assignment*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to external_identification_assignment"); }    do { // convert the 'source' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::external_identification_assignment, 1>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->source, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to external_identification_assignment to be a `external_source`")); }
+    } while (0);
+    return base;
+}
+
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<applied_external_identification_assignment>(const DB& db, const LIST& params, applied_external_identification_assignment* in)
+{
+    size_t base = GenericFill(db, params, static_cast<external_identification_assignment*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to applied_external_identification_assignment"); }    do { // convert the 'items' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->items, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to applied_external_identification_assignment to be a `SET [1:?] OF external_identification_item`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<group_assignment>(const DB& db, const LIST& params, group_assignment* in)
+{
+    size_t base = 0;
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to group_assignment"); }    do { // convert the 'assigned_group' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::group_assignment, 1>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->assigned_group, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to group_assignment to be a `group`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<applied_group_assignment>(const DB& db, const LIST& params, applied_group_assignment* in)
+{
+    size_t base = GenericFill(db, params, static_cast<group_assignment*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to applied_group_assignment"); }    do { // convert the 'items' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->items, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to applied_group_assignment to be a `SET [1:?] OF groupable_item`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<applied_identification_assignment>(const DB& db, const LIST& params, applied_identification_assignment* in)
+{
+    size_t base = GenericFill(db, params, static_cast<identification_assignment*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to applied_identification_assignment"); }    do { // convert the 'items' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->items, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to applied_identification_assignment to be a `SET [1:?] OF identification_item`")); }
+    } while (0);
+    return base;
+}
+
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<name_assignment>(const DB& db, const LIST& params, name_assignment* in)
+{
+    size_t base = 0;
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to name_assignment"); }    do { // convert the 'assigned_name' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::name_assignment, 1>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->assigned_name, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to name_assignment to be a `label`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<applied_name_assignment>(const DB& db, const LIST& params, applied_name_assignment* in)
+{
+    size_t base = GenericFill(db, params, static_cast<name_assignment*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to applied_name_assignment"); }    do { // convert the 'item' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->item, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to applied_name_assignment to be a `name_item`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<organization_assignment>(const DB& db, const LIST& params, organization_assignment* in)
+{
+    size_t base = 0;
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to organization_assignment"); }    do { // convert the 'assigned_organization' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::organization_assignment, 2>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->assigned_organization, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to organization_assignment to be a `organization`")); }
+    } while (0);
+    do { // convert the 'role' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::organization_assignment, 2>::aux_is_derived[1] = true; break; }
+        try { GenericConvert(in->role, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to organization_assignment to be a `organization_role`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<applied_organization_assignment>(const DB& db, const LIST& params, applied_organization_assignment* in)
+{
+    size_t base = GenericFill(db, params, static_cast<organization_assignment*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to applied_organization_assignment"); }    do { // convert the 'items' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->items, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to applied_organization_assignment to be a `SET [1:?] OF organization_item`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<organizational_project_assignment>(const DB& db, const LIST& params, organizational_project_assignment* in)
+{
+    size_t base = 0;
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to organizational_project_assignment"); }    do { // convert the 'assigned_organizational_project' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::organizational_project_assignment, 2>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->assigned_organizational_project, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to organizational_project_assignment to be a `organizational_project`")); }
+    } while (0);
+    do { // convert the 'role' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::organizational_project_assignment, 2>::aux_is_derived[1] = true; break; }
+        try { GenericConvert(in->role, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to organizational_project_assignment to be a `organizational_project_role`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<applied_organizational_project_assignment>(const DB& db, const LIST& params, applied_organizational_project_assignment* in)
+{
+    size_t base = GenericFill(db, params, static_cast<organizational_project_assignment*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to applied_organizational_project_assignment"); }    do { // convert the 'items' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->items, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to applied_organizational_project_assignment to be a `SET [1:?] OF project_item`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<person_and_organization_assignment>(const DB& db, const LIST& params, person_and_organization_assignment* in)
+{
+    size_t base = 0;
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to person_and_organization_assignment"); }    do { // convert the 'assigned_person_and_organization' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::person_and_organization_assignment, 2>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->assigned_person_and_organization, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to person_and_organization_assignment to be a `person_and_organization`")); }
+    } while (0);
+    do { // convert the 'role' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::person_and_organization_assignment, 2>::aux_is_derived[1] = true; break; }
+        try { GenericConvert(in->role, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to person_and_organization_assignment to be a `person_and_organization_role`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<applied_person_and_organization_assignment>(const DB& db, const LIST& params, applied_person_and_organization_assignment* in)
+{
+    size_t base = GenericFill(db, params, static_cast<person_and_organization_assignment*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to applied_person_and_organization_assignment"); }    do { // convert the 'items' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->items, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to applied_person_and_organization_assignment to be a `SET [1:?] OF person_and_organization_item`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<presented_item>(const DB& db, const LIST& params, presented_item* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<applied_presented_item>(const DB& db, const LIST& params, applied_presented_item* in)
+{
+    size_t base = GenericFill(db, params, static_cast<presented_item*>(in));
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to applied_presented_item"); }    do { // convert the 'items' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->items, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to applied_presented_item to be a `SET [1:?] OF presented_item_select`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<security_classification_assignment>(const DB& db, const LIST& params, security_classification_assignment* in)
+{
+    size_t base = 0;
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to security_classification_assignment"); }    do { // convert the 'assigned_security_classification' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::security_classification_assignment, 1>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->assigned_security_classification, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to security_classification_assignment to be a `security_classification`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<applied_security_classification_assignment>(const DB& db, const LIST& params, applied_security_classification_assignment* in)
+{
+    size_t base = GenericFill(db, params, static_cast<security_classification_assignment*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to applied_security_classification_assignment"); }    do { // convert the 'items' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->items, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to applied_security_classification_assignment to be a `SET [1:?] OF security_classification_item`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<time_interval_assignment>(const DB& db, const LIST& params, time_interval_assignment* in)
+{
+    size_t base = 0;
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to time_interval_assignment"); }    do { // convert the 'assigned_time_interval' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::time_interval_assignment, 2>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->assigned_time_interval, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to time_interval_assignment to be a `time_interval`")); }
+    } while (0);
+    do { // convert the 'role' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::time_interval_assignment, 2>::aux_is_derived[1] = true; break; }
+        try { GenericConvert(in->role, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to time_interval_assignment to be a `time_interval_role`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<applied_time_interval_assignment>(const DB& db, const LIST& params, applied_time_interval_assignment* in)
+{
+    size_t base = GenericFill(db, params, static_cast<time_interval_assignment*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to applied_time_interval_assignment"); }    do { // convert the 'items' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->items, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to applied_time_interval_assignment to be a `SET [0:?] OF time_interval_item`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<applied_usage_right>(const DB& db, const LIST& params, applied_usage_right* in)
+{
+    size_t base = GenericFill(db, params, static_cast<applied_action_assignment*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to applied_usage_right"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<area_in_set>(const DB& db, const LIST& params, area_in_set* in)
+{
+    size_t base = 0;
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to area_in_set"); }    do { // convert the 'area' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::area_in_set, 2>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->area, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to area_in_set to be a `presentation_area`")); }
+    } while (0);
+    do { // convert the 'in_set' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::area_in_set, 2>::aux_is_derived[1] = true; break; }
+        try { GenericConvert(in->in_set, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to area_in_set to be a `presentation_set`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<area_measure_with_unit>(const DB& db, const LIST& params, area_measure_with_unit* in)
+{
+    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to area_measure_with_unit"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<area_unit>(const DB& db, const LIST& params, area_unit* in)
+{
+    size_t base = GenericFill(db, params, static_cast<derived_unit*>(in));
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to area_unit"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<product_definition_relationship>(const DB& db, const LIST& params, product_definition_relationship* in)
+{
+    size_t base = 0;
+    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to product_definition_relationship"); }    do { // convert the 'id' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::product_definition_relationship, 5>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->id, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to product_definition_relationship to be a `identifier`")); }
+    } while (0);
+    do { // convert the 'name' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::product_definition_relationship, 5>::aux_is_derived[1] = true; break; }
+        try { GenericConvert(in->name, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to product_definition_relationship to be a `label`")); }
+    } while (0);
+    do { // convert the 'description' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::product_definition_relationship, 5>::aux_is_derived[2] = true; break; }
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert(in->description, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to product_definition_relationship to be a `text`")); }
+    } while (0);
+    do { // convert the 'relating_product_definition' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::product_definition_relationship, 5>::aux_is_derived[3] = true; break; }
+        try { GenericConvert(in->relating_product_definition, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to product_definition_relationship to be a `product_definition`")); }
+    } while (0);
+    do { // convert the 'related_product_definition' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::product_definition_relationship, 5>::aux_is_derived[4] = true; break; }
+        try { GenericConvert(in->related_product_definition, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to product_definition_relationship to be a `product_definition`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<product_definition_usage>(const DB& db, const LIST& params, product_definition_usage* in)
+{
+    size_t base = GenericFill(db, params, static_cast<product_definition_relationship*>(in));
+    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to product_definition_usage"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<assembly_component_usage>(const DB& db, const LIST& params, assembly_component_usage* in)
+{
+    size_t base = GenericFill(db, params, static_cast<product_definition_usage*>(in));
+    if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to assembly_component_usage"); }    do { // convert the 'reference_designator' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::assembly_component_usage, 1>::aux_is_derived[0] = true; break; }
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert(in->reference_designator, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to assembly_component_usage to be a `identifier`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<assigned_requirement>(const DB& db, const LIST& params, assigned_requirement* in)
+{
+    size_t base = GenericFill(db, params, static_cast<group_assignment*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to assigned_requirement"); }    do { // convert the 'items' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->items, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to assigned_requirement to be a `SET [1:1] OF product_definition`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<compound_representation_item>(const DB& db, const LIST& params, compound_representation_item* in)
+{
+    size_t base = GenericFill(db, params, static_cast<representation_item*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to compound_representation_item"); }    do { // convert the 'item_element' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::compound_representation_item, 1>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->item_element, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to compound_representation_item to be a `compound_item_definition`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<atomic_formula>(const DB& db, const LIST& params, atomic_formula* in)
+{
+    size_t base = GenericFill(db, params, static_cast<compound_representation_item*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to atomic_formula"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<attribute_assertion>(const DB& db, const LIST& params, attribute_assertion* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<attribute_language_assignment>(const DB& db, const LIST& params, attribute_language_assignment* in)
+{
+    size_t base = GenericFill(db, params, static_cast<attribute_classification_assignment*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to attribute_language_assignment"); }    do { // convert the 'items' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->items, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to attribute_language_assignment to be a `SET [1:?] OF attribute_language_item`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<attribute_value_assignment>(const DB& db, const LIST& params, attribute_value_assignment* in)
+{
+    size_t base = 0;
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to attribute_value_assignment"); }    do { // convert the 'attribute_name' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::attribute_value_assignment, 3>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->attribute_name, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to attribute_value_assignment to be a `label`")); }
+    } while (0);
+    do { // convert the 'attribute_value' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::attribute_value_assignment, 3>::aux_is_derived[1] = true; break; }
+        try { GenericConvert(in->attribute_value, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to attribute_value_assignment to be a `attribute_type`")); }
+    } while (0);
+    do { // convert the 'role' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::attribute_value_assignment, 3>::aux_is_derived[2] = true; break; }
+        try { GenericConvert(in->role, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to attribute_value_assignment to be a `attribute_value_role`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<auxiliary_geometric_representation_item>(const DB& db, const LIST& params, auxiliary_geometric_representation_item* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<placement>(const DB& db, const LIST& params, placement* in)
+{
+    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to placement"); }    do { // convert the 'location' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::placement, 1>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->location, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to placement to be a `cartesian_point`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<axis1_placement>(const DB& db, const LIST& params, axis1_placement* in)
+{
+    size_t base = GenericFill(db, params, static_cast<placement*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to axis1_placement"); }    do { // convert the 'axis' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert(in->axis, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to axis1_placement to be a `direction`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<axis2_placement_2d>(const DB& db, const LIST& params, axis2_placement_2d* in)
+{
+    size_t base = GenericFill(db, params, static_cast<placement*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to axis2_placement_2d"); }    do { // convert the 'ref_direction' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert(in->ref_direction, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to axis2_placement_2d to be a `direction`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<axis2_placement_3d>(const DB& db, const LIST& params, axis2_placement_3d* in)
+{
+    size_t base = GenericFill(db, params, static_cast<placement*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to axis2_placement_3d"); }    do { // convert the 'axis' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert(in->axis, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to axis2_placement_3d to be a `direction`")); }
+    } while (0);
+    do { // convert the 'ref_direction' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert(in->ref_direction, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to axis2_placement_3d to be a `direction`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<curve>(const DB& db, const LIST& params, curve* in)
+{
+    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to curve"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<bounded_curve>(const DB& db, const LIST& params, bounded_curve* in)
+{
+    size_t base = GenericFill(db, params, static_cast<curve*>(in));
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to bounded_curve"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<b_spline_curve>(const DB& db, const LIST& params, b_spline_curve* in)
+{
+    size_t base = GenericFill(db, params, static_cast<bounded_curve*>(in));
+    if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to b_spline_curve"); }    do { // convert the 'degree' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::b_spline_curve, 5>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->degree, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to b_spline_curve to be a `INTEGER`")); }
+    } while (0);
+    do { // convert the 'control_points_list' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::b_spline_curve, 5>::aux_is_derived[1] = true; break; }
+        try { GenericConvert(in->control_points_list, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to b_spline_curve to be a `LIST [2:?] OF cartesian_point`")); }
+    } while (0);
+    do { // convert the 'curve_form' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::b_spline_curve, 5>::aux_is_derived[2] = true; break; }
+        try { GenericConvert(in->curve_form, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to b_spline_curve to be a `b_spline_curve_form`")); }
+    } while (0);
+    do { // convert the 'closed_curve' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::b_spline_curve, 5>::aux_is_derived[3] = true; break; }
+        try { GenericConvert(in->closed_curve, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to b_spline_curve to be a `LOGICAL`")); }
+    } while (0);
+    do { // convert the 'self_intersect' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::b_spline_curve, 5>::aux_is_derived[4] = true; break; }
+        try { GenericConvert(in->self_intersect, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to b_spline_curve to be a `LOGICAL`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<b_spline_curve_with_knots>(const DB& db, const LIST& params, b_spline_curve_with_knots* in)
+{
+    size_t base = GenericFill(db, params, static_cast<b_spline_curve*>(in));
+    if (params.GetSize() < 9) { throw STEP::TypeError("expected 9 arguments to b_spline_curve_with_knots"); }    do { // convert the 'knot_multiplicities' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->knot_multiplicities, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to b_spline_curve_with_knots to be a `LIST [2:?] OF INTEGER`")); }
+    } while (0);
+    do { // convert the 'knots' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->knots, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to b_spline_curve_with_knots to be a `LIST [2:?] OF parameter_value`")); }
+    } while (0);
+    do { // convert the 'knot_spec' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->knot_spec, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 8 to b_spline_curve_with_knots to be a `knot_type`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<surface>(const DB& db, const LIST& params, surface* in)
+{
+    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to surface"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<bounded_surface>(const DB& db, const LIST& params, bounded_surface* in)
+{
+    size_t base = GenericFill(db, params, static_cast<surface*>(in));
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to bounded_surface"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<b_spline_surface>(const DB& db, const LIST& params, b_spline_surface* in)
+{
+    size_t base = GenericFill(db, params, static_cast<bounded_surface*>(in));
+    if (params.GetSize() < 7) { throw STEP::TypeError("expected 7 arguments to b_spline_surface"); }    do { // convert the 'u_degree' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::b_spline_surface, 6>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->u_degree, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to b_spline_surface to be a `INTEGER`")); }
+    } while (0);
+    do { // convert the 'v_degree' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::b_spline_surface, 6>::aux_is_derived[1] = true; break; }
+        try { GenericConvert(in->v_degree, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to b_spline_surface to be a `INTEGER`")); }
+    } while (0);
+    do { // convert the 'surface_form' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::b_spline_surface, 6>::aux_is_derived[2] = true; break; }
+        try { GenericConvert(in->surface_form, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to b_spline_surface to be a `b_spline_surface_form`")); }
+    } while (0);
+    do { // convert the 'u_closed' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::b_spline_surface, 6>::aux_is_derived[3] = true; break; }
+        try { GenericConvert(in->u_closed, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to b_spline_surface to be a `LOGICAL`")); }
+    } while (0);
+    do { // convert the 'v_closed' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::b_spline_surface, 6>::aux_is_derived[4] = true; break; }
+        try { GenericConvert(in->v_closed, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to b_spline_surface to be a `LOGICAL`")); }
+    } while (0);
+    do { // convert the 'self_intersect' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::b_spline_surface, 6>::aux_is_derived[5] = true; break; }
+        try { GenericConvert(in->self_intersect, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to b_spline_surface to be a `LOGICAL`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<b_spline_surface_with_knots>(const DB& db, const LIST& params, b_spline_surface_with_knots* in)
+{
+    size_t base = GenericFill(db, params, static_cast<b_spline_surface*>(in));
+    if (params.GetSize() < 12) { throw STEP::TypeError("expected 12 arguments to b_spline_surface_with_knots"); }    do { // convert the 'u_multiplicities' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->u_multiplicities, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to b_spline_surface_with_knots to be a `LIST [2:?] OF INTEGER`")); }
+    } while (0);
+    do { // convert the 'v_multiplicities' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->v_multiplicities, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 8 to b_spline_surface_with_knots to be a `LIST [2:?] OF INTEGER`")); }
+    } while (0);
+    do { // convert the 'u_knots' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->u_knots, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 9 to b_spline_surface_with_knots to be a `LIST [2:?] OF parameter_value`")); }
+    } while (0);
+    do { // convert the 'v_knots' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->v_knots, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 10 to b_spline_surface_with_knots to be a `LIST [2:?] OF parameter_value`")); }
+    } while (0);
+    do { // convert the 'knot_spec' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->knot_spec, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 11 to b_spline_surface_with_knots to be a `knot_type`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<product_definition>(const DB& db, const LIST& params, product_definition* in)
+{
+    size_t base = 0;
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to product_definition"); }    do { // convert the 'id' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::product_definition, 4>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->id, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to product_definition to be a `identifier`")); }
+    } while (0);
+    do { // convert the 'description' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::product_definition, 4>::aux_is_derived[1] = true; break; }
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert(in->description, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to product_definition to be a `text`")); }
+    } while (0);
+    do { // convert the 'formation' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::product_definition, 4>::aux_is_derived[2] = true; break; }
+        try { GenericConvert(in->formation, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to product_definition to be a `product_definition_formation`")); }
+    } while (0);
+    do { // convert the 'frame_of_reference' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::product_definition, 4>::aux_is_derived[3] = true; break; }
+        try { GenericConvert(in->frame_of_reference, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to product_definition to be a `product_definition_context`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<rule_software_definition>(const DB& db, const LIST& params, rule_software_definition* in)
+{
+    size_t base = GenericFill(db, params, static_cast<product_definition*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to rule_software_definition"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<rule_definition>(const DB& db, const LIST& params, rule_definition* in)
+{
+    size_t base = GenericFill(db, params, static_cast<rule_software_definition*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to rule_definition"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<back_chaining_rule>(const DB& db, const LIST& params, back_chaining_rule* in)
+{
+    size_t base = GenericFill(db, params, static_cast<rule_definition*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to back_chaining_rule"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<back_chaining_rule_body>(const DB& db, const LIST& params, back_chaining_rule_body* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<colour>(const DB& db, const LIST& params, colour* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<background_colour>(const DB& db, const LIST& params, background_colour* in)
+{
+    size_t base = GenericFill(db, params, static_cast<colour*>(in));
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to background_colour"); }    do { // convert the 'presentation' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->presentation, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to background_colour to be a `area_or_view`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<beveled_sheet_representation>(const DB& db, const LIST& params, beveled_sheet_representation* in)
+{
+    size_t base = GenericFill(db, params, static_cast<shape_representation*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to beveled_sheet_representation"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<bezier_curve>(const DB& db, const LIST& params, bezier_curve* in)
+{
+    size_t base = GenericFill(db, params, static_cast<b_spline_curve*>(in));
+    if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to bezier_curve"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<bezier_surface>(const DB& db, const LIST& params, bezier_surface* in)
+{
+    size_t base = GenericFill(db, params, static_cast<b_spline_surface*>(in));
+    if (params.GetSize() < 7) { throw STEP::TypeError("expected 7 arguments to bezier_surface"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<generic_expression>(const DB& db, const LIST& params, generic_expression* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<binary_generic_expression>(const DB& db, const LIST& params, binary_generic_expression* in)
+{
+    size_t base = GenericFill(db, params, static_cast<generic_expression*>(in));
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to binary_generic_expression"); }    do { // convert the 'operands' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->operands, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to binary_generic_expression to be a `LIST [2:2] OF generic_expression`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<binary_numeric_expression>(const DB& db, const LIST& params, binary_numeric_expression* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<binary_representation_item>(const DB& db, const LIST& params, binary_representation_item* in)
+{
+    size_t base = GenericFill(db, params, static_cast<representation_item*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to binary_representation_item"); }    do { // convert the 'binary_value' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::binary_representation_item, 1>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->binary_value, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to binary_representation_item to be a `BINARY`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<block>(const DB& db, const LIST& params, block* in)
+{
+    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
+    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to block"); }    do { // convert the 'position' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->position, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to block to be a `axis2_placement_3d`")); }
+    } while (0);
+    do { // convert the 'x' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->x, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to block to be a `positive_length_measure`")); }
+    } while (0);
+    do { // convert the 'y' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->y, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to block to be a `positive_length_measure`")); }
+    } while (0);
+    do { // convert the 'z' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->z, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to block to be a `positive_length_measure`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<expression>(const DB& db, const LIST& params, expression* in)
+{
+    size_t base = GenericFill(db, params, static_cast<generic_expression*>(in));
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<boolean_expression>(const DB& db, const LIST& params, boolean_expression* in)
+{
+    size_t base = GenericFill(db, params, static_cast<expression*>(in));
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<boolean_literal>(const DB& db, const LIST& params, boolean_literal* in)
+{
+    size_t base = 0;
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to boolean_literal"); }    do { // convert the 'the_value' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->the_value, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to boolean_literal to be a `BOOLEAN`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<boolean_representation_item>(const DB& db, const LIST& params, boolean_representation_item* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<boolean_result>(const DB& db, const LIST& params, boolean_result* in)
+{
+    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to boolean_result"); }    do { // convert the 'operator' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->operator_, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to boolean_result to be a `boolean_operator`")); }
+    } while (0);
+    do { // convert the 'first_operand' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->first_operand, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to boolean_result to be a `boolean_operand`")); }
+    } while (0);
+    do { // convert the 'second_operand' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->second_operand, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to boolean_result to be a `boolean_operand`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<composite_curve>(const DB& db, const LIST& params, composite_curve* in)
+{
+    size_t base = GenericFill(db, params, static_cast<bounded_curve*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to composite_curve"); }    do { // convert the 'segments' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::composite_curve, 2>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->segments, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to composite_curve to be a `LIST [1:?] OF composite_curve_segment`")); }
+    } while (0);
+    do { // convert the 'self_intersect' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::composite_curve, 2>::aux_is_derived[1] = true; break; }
+        try { GenericConvert(in->self_intersect, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to composite_curve to be a `LOGICAL`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<composite_curve_on_surface>(const DB& db, const LIST& params, composite_curve_on_surface* in)
+{
+    size_t base = GenericFill(db, params, static_cast<composite_curve*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to composite_curve_on_surface"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<boundary_curve>(const DB& db, const LIST& params, boundary_curve* in)
+{
+    size_t base = GenericFill(db, params, static_cast<composite_curve_on_surface*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to boundary_curve"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<bounded_pcurve>(const DB& db, const LIST& params, bounded_pcurve* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<bounded_surface_curve>(const DB& db, const LIST& params, bounded_surface_curve* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<founded_item>(const DB& db, const LIST& params, founded_item* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<box_domain>(const DB& db, const LIST& params, box_domain* in)
+{
+    size_t base = GenericFill(db, params, static_cast<founded_item*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to box_domain"); }    do { // convert the 'corner' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->corner, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to box_domain to be a `cartesian_point`")); }
+    } while (0);
+    do { // convert the 'xlength' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->xlength, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to box_domain to be a `positive_length_measure`")); }
+    } while (0);
+    do { // convert the 'ylength' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->ylength, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to box_domain to be a `positive_length_measure`")); }
+    } while (0);
+    do { // convert the 'zlength' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->zlength, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to box_domain to be a `positive_length_measure`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<half_space_solid>(const DB& db, const LIST& params, half_space_solid* in)
+{
+    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to half_space_solid"); }    do { // convert the 'base_surface' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::half_space_solid, 2>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->base_surface, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to half_space_solid to be a `surface`")); }
+    } while (0);
+    do { // convert the 'agreement_flag' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::half_space_solid, 2>::aux_is_derived[1] = true; break; }
+        try { GenericConvert(in->agreement_flag, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to half_space_solid to be a `BOOLEAN`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<boxed_half_space>(const DB& db, const LIST& params, boxed_half_space* in)
+{
+    size_t base = GenericFill(db, params, static_cast<half_space_solid*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to boxed_half_space"); }    do { // convert the 'enclosure' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->enclosure, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to boxed_half_space to be a `box_domain`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<breakdown_context>(const DB& db, const LIST& params, breakdown_context* in)
+{
+    size_t base = GenericFill(db, params, static_cast<product_definition_relationship*>(in));
+    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to breakdown_context"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<breakdown_element_group_assignment>(const DB& db, const LIST& params, breakdown_element_group_assignment* in)
+{
+    size_t base = GenericFill(db, params, static_cast<group_assignment*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to breakdown_element_group_assignment"); }    do { // convert the 'items' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->items, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to breakdown_element_group_assignment to be a `SET [1:1] OF product_definition_or_breakdown_element_usage`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<breakdown_element_realization>(const DB& db, const LIST& params, breakdown_element_realization* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<breakdown_element_usage>(const DB& db, const LIST& params, breakdown_element_usage* in)
+{
+    size_t base = GenericFill(db, params, static_cast<product_definition_relationship*>(in));
+    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to breakdown_element_usage"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<breakdown_of>(const DB& db, const LIST& params, breakdown_of* in)
+{
+    size_t base = GenericFill(db, params, static_cast<product_definition_relationship*>(in));
+    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to breakdown_of"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<solid_model>(const DB& db, const LIST& params, solid_model* in)
+{
+    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to solid_model"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<manifold_solid_brep>(const DB& db, const LIST& params, manifold_solid_brep* in)
+{
+    size_t base = GenericFill(db, params, static_cast<solid_model*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to manifold_solid_brep"); }    do { // convert the 'outer' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::manifold_solid_brep, 1>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->outer, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to manifold_solid_brep to be a `closed_shell`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<brep_with_voids>(const DB& db, const LIST& params, brep_with_voids* in)
+{
+    size_t base = GenericFill(db, params, static_cast<manifold_solid_brep*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to brep_with_voids"); }    do { // convert the 'voids' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->voids, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to brep_with_voids to be a `SET [1:?] OF oriented_closed_shell`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<bytes_representation_item>(const DB& db, const LIST& params, bytes_representation_item* in)
+{
+    size_t base = GenericFill(db, params, static_cast<binary_representation_item*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to bytes_representation_item"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<date>(const DB& db, const LIST& params, date* in)
+{
+    size_t base = 0;
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to date"); }    do { // convert the 'year_component' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::date, 1>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->year_component, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to date to be a `year_number`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<calendar_date>(const DB& db, const LIST& params, calendar_date* in)
+{
+    size_t base = GenericFill(db, params, static_cast<date*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to calendar_date"); }    do { // convert the 'day_component' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->day_component, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to calendar_date to be a `day_in_month_number`")); }
+    } while (0);
+    do { // convert the 'month_component' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->month_component, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to calendar_date to be a `month_in_year_number`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<camera_image>(const DB& db, const LIST& params, camera_image* in)
+{
+    size_t base = GenericFill(db, params, static_cast<mapped_item*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to camera_image"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<camera_image_3d_with_scale>(const DB& db, const LIST& params, camera_image_3d_with_scale* in)
+{
+    size_t base = GenericFill(db, params, static_cast<camera_image*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to camera_image_3d_with_scale"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<camera_model>(const DB& db, const LIST& params, camera_model* in)
+{
+    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to camera_model"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<camera_model_d3>(const DB& db, const LIST& params, camera_model_d3* in)
+{
+    size_t base = GenericFill(db, params, static_cast<camera_model*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to camera_model_d3"); }    do { // convert the 'view_reference_system' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::camera_model_d3, 2>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->view_reference_system, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to camera_model_d3 to be a `axis2_placement_3d`")); }
+    } while (0);
+    do { // convert the 'perspective_of_volume' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::camera_model_d3, 2>::aux_is_derived[1] = true; break; }
+        try { GenericConvert(in->perspective_of_volume, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to camera_model_d3 to be a `view_volume`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<camera_model_d3_multi_clipping>(const DB& db, const LIST& params, camera_model_d3_multi_clipping* in)
+{
+    size_t base = GenericFill(db, params, static_cast<camera_model_d3*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to camera_model_d3_multi_clipping"); }    do { // convert the 'shape_clipping' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->shape_clipping, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to camera_model_d3_multi_clipping to be a `SET [1:?] OF camera_model_d3_multi_clipping_interection_select`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<camera_model_d3_multi_clipping_intersection>(const DB& db, const LIST& params, camera_model_d3_multi_clipping_intersection* in)
+{
+    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to camera_model_d3_multi_clipping_intersection"); }    do { // convert the 'shape_clipping' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->shape_clipping, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to camera_model_d3_multi_clipping_intersection to be a `SET [2:?] OF camera_model_d3_multi_clipping_interection_select`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<camera_model_d3_multi_clipping_union>(const DB& db, const LIST& params, camera_model_d3_multi_clipping_union* in)
+{
+    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to camera_model_d3_multi_clipping_union"); }    do { // convert the 'shape_clipping' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->shape_clipping, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to camera_model_d3_multi_clipping_union to be a `SET [2:?] OF camera_model_d3_multi_clipping_union_select`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<camera_model_d3_with_hlhsr>(const DB& db, const LIST& params, camera_model_d3_with_hlhsr* in)
+{
+    size_t base = GenericFill(db, params, static_cast<camera_model_d3*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to camera_model_d3_with_hlhsr"); }    do { // convert the 'hidden_line_surface_removal' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->hidden_line_surface_removal, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to camera_model_d3_with_hlhsr to be a `BOOLEAN`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<camera_model_with_light_sources>(const DB& db, const LIST& params, camera_model_with_light_sources* in)
+{
+    size_t base = GenericFill(db, params, static_cast<camera_model_d3*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to camera_model_with_light_sources"); }    do { // convert the 'sources' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->sources, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to camera_model_with_light_sources to be a `SET [1:?] OF light_source`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<representation_map>(const DB& db, const LIST& params, representation_map* in)
+{
+    size_t base = 0;
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to representation_map"); }    do { // convert the 'mapping_origin' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::representation_map, 2>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->mapping_origin, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to representation_map to be a `representation_item`")); }
+    } while (0);
+    do { // convert the 'mapped_representation' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::representation_map, 2>::aux_is_derived[1] = true; break; }
+        try { GenericConvert(in->mapped_representation, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to representation_map to be a `representation`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<camera_usage>(const DB& db, const LIST& params, camera_usage* in)
+{
+    size_t base = GenericFill(db, params, static_cast<representation_map*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to camera_usage"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<capacitance_measure_with_unit>(const DB& db, const LIST& params, capacitance_measure_with_unit* in)
+{
+    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to capacitance_measure_with_unit"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<capacitance_unit>(const DB& db, const LIST& params, capacitance_unit* in)
+{
+    size_t base = GenericFill(db, params, static_cast<derived_unit*>(in));
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to capacitance_unit"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<point>(const DB& db, const LIST& params, point* in)
+{
+    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to point"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<cartesian_point>(const DB& db, const LIST& params, cartesian_point* in)
+{
+    size_t base = GenericFill(db, params, static_cast<point*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to cartesian_point"); }    do { // convert the 'coordinates' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->coordinates, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to cartesian_point to be a `LIST [1:3] OF length_measure`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<cartesian_transformation_operator>(const DB& db, const LIST& params, cartesian_transformation_operator* in)
+{
+    size_t base = 0;
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to cartesian_transformation_operator"); }    do { // convert the 'axis1' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::cartesian_transformation_operator, 4>::aux_is_derived[0] = true; break; }
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert(in->axis1, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to cartesian_transformation_operator to be a `direction`")); }
+    } while (0);
+    do { // convert the 'axis2' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::cartesian_transformation_operator, 4>::aux_is_derived[1] = true; break; }
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert(in->axis2, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to cartesian_transformation_operator to be a `direction`")); }
+    } while (0);
+    do { // convert the 'local_origin' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::cartesian_transformation_operator, 4>::aux_is_derived[2] = true; break; }
+        try { GenericConvert(in->local_origin, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to cartesian_transformation_operator to be a `cartesian_point`")); }
+    } while (0);
+    do { // convert the 'scale' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::cartesian_transformation_operator, 4>::aux_is_derived[3] = true; break; }
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert(in->scale, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to cartesian_transformation_operator to be a `REAL`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<cartesian_transformation_operator_2d>(const DB& db, const LIST& params, cartesian_transformation_operator_2d* in)
+{
+    size_t base = GenericFill(db, params, static_cast<cartesian_transformation_operator*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to cartesian_transformation_operator_2d"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<cartesian_transformation_operator_3d>(const DB& db, const LIST& params, cartesian_transformation_operator_3d* in)
+{
+    size_t base = GenericFill(db, params, static_cast<cartesian_transformation_operator*>(in));
+    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to cartesian_transformation_operator_3d"); }    do { // convert the 'axis3' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert(in->axis3, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to cartesian_transformation_operator_3d to be a `direction`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<cc_design_approval>(const DB& db, const LIST& params, cc_design_approval* in)
+{
+    size_t base = GenericFill(db, params, static_cast<approval_assignment*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to cc_design_approval"); }    do { // convert the 'items' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->items, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to cc_design_approval to be a `SET [1:?] OF approved_item`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<cc_design_certification>(const DB& db, const LIST& params, cc_design_certification* in)
+{
+    size_t base = GenericFill(db, params, static_cast<certification_assignment*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to cc_design_certification"); }    do { // convert the 'items' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->items, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to cc_design_certification to be a `SET [1:?] OF certified_item`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<cc_design_contract>(const DB& db, const LIST& params, cc_design_contract* in)
+{
+    size_t base = GenericFill(db, params, static_cast<contract_assignment*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to cc_design_contract"); }    do { // convert the 'items' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->items, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to cc_design_contract to be a `SET [1:?] OF contracted_item`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<cc_design_date_and_time_assignment>(const DB& db, const LIST& params, cc_design_date_and_time_assignment* in)
+{
+    size_t base = GenericFill(db, params, static_cast<date_and_time_assignment*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to cc_design_date_and_time_assignment"); }    do { // convert the 'items' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->items, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to cc_design_date_and_time_assignment to be a `SET [1:?] OF date_time_item`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<cc_design_person_and_organization_assignment>(const DB& db, const LIST& params, cc_design_person_and_organization_assignment* in)
+{
+    size_t base = GenericFill(db, params, static_cast<person_and_organization_assignment*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to cc_design_person_and_organization_assignment"); }    do { // convert the 'items' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->items, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to cc_design_person_and_organization_assignment to be a `SET [1:?] OF cc_person_organization_item`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<cc_design_security_classification>(const DB& db, const LIST& params, cc_design_security_classification* in)
+{
+    size_t base = GenericFill(db, params, static_cast<security_classification_assignment*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to cc_design_security_classification"); }    do { // convert the 'items' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->items, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to cc_design_security_classification to be a `SET [1:?] OF cc_classified_item`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<cc_design_specification_reference>(const DB& db, const LIST& params, cc_design_specification_reference* in)
+{
+    size_t base = GenericFill(db, params, static_cast<document_reference*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to cc_design_specification_reference"); }    do { // convert the 'items' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->items, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to cc_design_specification_reference to be a `SET [1:?] OF cc_specified_item`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<celsius_temperature_measure_with_unit>(const DB& db, const LIST& params, celsius_temperature_measure_with_unit* in)
+{
+    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to celsius_temperature_measure_with_unit"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<centre_of_symmetry>(const DB& db, const LIST& params, centre_of_symmetry* in)
+{
+    size_t base = GenericFill(db, params, static_cast<derived_shape_aspect*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to centre_of_symmetry"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<change>(const DB& db, const LIST& params, change* in)
+{
+    size_t base = GenericFill(db, params, static_cast<action_assignment*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to change"); }    do { // convert the 'items' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->items, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to change to be a `SET [1:?] OF work_item`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<change_request>(const DB& db, const LIST& params, change_request* in)
+{
+    size_t base = GenericFill(db, params, static_cast<action_request_assignment*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to change_request"); }    do { // convert the 'items' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->items, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to change_request to be a `SET [1:?] OF change_request_item`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<character_glyph_style_outline>(const DB& db, const LIST& params, character_glyph_style_outline* in)
+{
+    size_t base = GenericFill(db, params, static_cast<founded_item*>(in));
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to character_glyph_style_outline"); }    do { // convert the 'outline_style' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->outline_style, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to character_glyph_style_outline to be a `curve_style`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<character_glyph_style_stroke>(const DB& db, const LIST& params, character_glyph_style_stroke* in)
+{
+    size_t base = GenericFill(db, params, static_cast<founded_item*>(in));
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to character_glyph_style_stroke"); }    do { // convert the 'stroke_style' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->stroke_style, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to character_glyph_style_stroke to be a `curve_style`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<symbol_representation>(const DB& db, const LIST& params, symbol_representation* in)
+{
+    size_t base = GenericFill(db, params, static_cast<representation*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to symbol_representation"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<generic_character_glyph_symbol>(const DB& db, const LIST& params, generic_character_glyph_symbol* in)
+{
+    size_t base = GenericFill(db, params, static_cast<symbol_representation*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to generic_character_glyph_symbol"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<character_glyph_symbol>(const DB& db, const LIST& params, character_glyph_symbol* in)
+{
+    size_t base = GenericFill(db, params, static_cast<generic_character_glyph_symbol*>(in));
+    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to character_glyph_symbol"); }    do { // convert the 'character_box' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::character_glyph_symbol, 2>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->character_box, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to character_glyph_symbol to be a `planar_extent`")); }
+    } while (0);
+    do { // convert the 'baseline_ratio' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::character_glyph_symbol, 2>::aux_is_derived[1] = true; break; }
+        try { GenericConvert(in->baseline_ratio, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to character_glyph_symbol to be a `ratio_measure`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<character_glyph_symbol_outline>(const DB& db, const LIST& params, character_glyph_symbol_outline* in)
+{
+    size_t base = GenericFill(db, params, static_cast<character_glyph_symbol*>(in));
+    if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to character_glyph_symbol_outline"); }    do { // convert the 'outlines' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->outlines, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to character_glyph_symbol_outline to be a `SET [1:?] OF annotation_fill_area`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<character_glyph_symbol_stroke>(const DB& db, const LIST& params, character_glyph_symbol_stroke* in)
+{
+    size_t base = GenericFill(db, params, static_cast<character_glyph_symbol*>(in));
+    if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to character_glyph_symbol_stroke"); }    do { // convert the 'strokes' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->strokes, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to character_glyph_symbol_stroke to be a `SET [1:?] OF curve`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<general_property>(const DB& db, const LIST& params, general_property* in)
+{
+    size_t base = 0;
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to general_property"); }    do { // convert the 'id' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::general_property, 3>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->id, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to general_property to be a `identifier`")); }
+    } while (0);
+    do { // convert the 'name' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::general_property, 3>::aux_is_derived[1] = true; break; }
+        try { GenericConvert(in->name, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to general_property to be a `label`")); }
+    } while (0);
+    do { // convert the 'description' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::general_property, 3>::aux_is_derived[2] = true; break; }
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert(in->description, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to general_property to be a `text`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<characteristic_data_column_header>(const DB& db, const LIST& params, characteristic_data_column_header* in)
+{
+    size_t base = GenericFill(db, params, static_cast<general_property*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to characteristic_data_column_header"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<general_property_relationship>(const DB& db, const LIST& params, general_property_relationship* in)
+{
+    size_t base = 0;
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to general_property_relationship"); }    do { // convert the 'name' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::general_property_relationship, 4>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->name, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to general_property_relationship to be a `label`")); }
+    } while (0);
+    do { // convert the 'description' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::general_property_relationship, 4>::aux_is_derived[1] = true; break; }
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert(in->description, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to general_property_relationship to be a `text`")); }
+    } while (0);
+    do { // convert the 'relating_property' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::general_property_relationship, 4>::aux_is_derived[2] = true; break; }
+        try { GenericConvert(in->relating_property, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to general_property_relationship to be a `general_property`")); }
+    } while (0);
+    do { // convert the 'related_property' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::general_property_relationship, 4>::aux_is_derived[3] = true; break; }
+        try { GenericConvert(in->related_property, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to general_property_relationship to be a `general_property`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<characteristic_data_column_header_link>(const DB& db, const LIST& params, characteristic_data_column_header_link* in)
+{
+    size_t base = GenericFill(db, params, static_cast<general_property_relationship*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to characteristic_data_column_header_link"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<characteristic_data_table_header>(const DB& db, const LIST& params, characteristic_data_table_header* in)
+{
+    size_t base = GenericFill(db, params, static_cast<general_property*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to characteristic_data_table_header"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<characteristic_data_table_header_decomposition>(const DB& db, const LIST& params, characteristic_data_table_header_decomposition* in)
+{
+    size_t base = GenericFill(db, params, static_cast<general_property_relationship*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to characteristic_data_table_header_decomposition"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<group>(const DB& db, const LIST& params, group* in)
+{
+    size_t base = 0;
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to group"); }    do { // convert the 'name' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::group, 2>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->name, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to group to be a `label`")); }
+    } while (0);
+    do { // convert the 'description' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::group, 2>::aux_is_derived[1] = true; break; }
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert(in->description, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to group to be a `text`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<characteristic_type>(const DB& db, const LIST& params, characteristic_type* in)
+{
+    size_t base = GenericFill(db, params, static_cast<group*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to characteristic_type"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<characterized_class>(const DB& db, const LIST& params, characterized_class* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<characterized_object>(const DB& db, const LIST& params, characterized_object* in)
+{
+    size_t base = 0;
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to characterized_object"); }    do { // convert the 'name' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::characterized_object, 2>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->name, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to characterized_object to be a `label`")); }
+    } while (0);
+    do { // convert the 'description' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::characterized_object, 2>::aux_is_derived[1] = true; break; }
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert(in->description, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to characterized_object to be a `text`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<conic>(const DB& db, const LIST& params, conic* in)
+{
+    size_t base = GenericFill(db, params, static_cast<curve*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to conic"); }    do { // convert the 'position' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::conic, 1>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->position, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to conic to be a `axis2_placement`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<circle>(const DB& db, const LIST& params, circle* in)
+{
+    size_t base = GenericFill(db, params, static_cast<conic*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to circle"); }    do { // convert the 'radius' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->radius, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to circle to be a `positive_length_measure`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<circular_runout_tolerance>(const DB& db, const LIST& params, circular_runout_tolerance* in)
+{
+    size_t base = GenericFill(db, params, static_cast<geometric_tolerance_with_datum_reference*>(in));
+    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to circular_runout_tolerance"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<class_by_extension>(const DB& db, const LIST& params, class_by_extension* in)
+{
+    size_t base = GenericFill(db, params, static_cast<class_t*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to class_by_extension"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<class_by_intension>(const DB& db, const LIST& params, class_by_intension* in)
+{
+    size_t base = GenericFill(db, params, static_cast<class_t*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to class_by_intension"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<class_system>(const DB& db, const LIST& params, class_system* in)
+{
+    size_t base = GenericFill(db, params, static_cast<group*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to class_system"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<effectivity_context_assignment>(const DB& db, const LIST& params, effectivity_context_assignment* in)
+{
+    size_t base = 0;
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to effectivity_context_assignment"); }    do { // convert the 'assigned_effectivity_assignment' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::effectivity_context_assignment, 2>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->assigned_effectivity_assignment, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to effectivity_context_assignment to be a `effectivity_assignment`")); }
+    } while (0);
+    do { // convert the 'role' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::effectivity_context_assignment, 2>::aux_is_derived[1] = true; break; }
+        try { GenericConvert(in->role, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to effectivity_context_assignment to be a `effectivity_context_role`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<class_usage_effectivity_context_assignment>(const DB& db, const LIST& params, class_usage_effectivity_context_assignment* in)
+{
+    size_t base = GenericFill(db, params, static_cast<effectivity_context_assignment*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to class_usage_effectivity_context_assignment"); }    do { // convert the 'items' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->items, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to class_usage_effectivity_context_assignment to be a `SET [1:?] OF class_usage_effectivity_context_item`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<topological_representation_item>(const DB& db, const LIST& params, topological_representation_item* in)
+{
+    size_t base = GenericFill(db, params, static_cast<representation_item*>(in));
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to topological_representation_item"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<connected_face_set>(const DB& db, const LIST& params, connected_face_set* in)
+{
+    size_t base = GenericFill(db, params, static_cast<topological_representation_item*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to connected_face_set"); }    do { // convert the 'cfs_faces' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::connected_face_set, 1>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->cfs_faces, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to connected_face_set to be a `SET [1:?] OF face`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<closed_shell>(const DB& db, const LIST& params, closed_shell* in)
+{
+    size_t base = GenericFill(db, params, static_cast<connected_face_set*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to closed_shell"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<coaxiality_tolerance>(const DB& db, const LIST& params, coaxiality_tolerance* in)
+{
+    size_t base = GenericFill(db, params, static_cast<geometric_tolerance_with_datum_reference*>(in));
+    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to coaxiality_tolerance"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<colour_specification>(const DB& db, const LIST& params, colour_specification* in)
+{
+    size_t base = GenericFill(db, params, static_cast<colour*>(in));
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to colour_specification"); }    do { // convert the 'name' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::colour_specification, 1>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->name, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to colour_specification to be a `label`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<colour_rgb>(const DB& db, const LIST& params, colour_rgb* in)
+{
+    size_t base = GenericFill(db, params, static_cast<colour_specification*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to colour_rgb"); }    do { // convert the 'red' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->red, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to colour_rgb to be a `REAL`")); }
+    } while (0);
+    do { // convert the 'green' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->green, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to colour_rgb to be a `REAL`")); }
+    } while (0);
+    do { // convert the 'blue' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->blue, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to colour_rgb to be a `REAL`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<common_datum>(const DB& db, const LIST& params, common_datum* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<comparison_expression>(const DB& db, const LIST& params, comparison_expression* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<complex_clause>(const DB& db, const LIST& params, complex_clause* in)
+{
+    size_t base = GenericFill(db, params, static_cast<compound_representation_item*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to complex_clause"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<complex_conjunctive_clause>(const DB& db, const LIST& params, complex_conjunctive_clause* in)
+{
+    size_t base = GenericFill(db, params, static_cast<complex_clause*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to complex_conjunctive_clause"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<complex_disjunctive_clause>(const DB& db, const LIST& params, complex_disjunctive_clause* in)
+{
+    size_t base = GenericFill(db, params, static_cast<complex_clause*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to complex_disjunctive_clause"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<modified_solid>(const DB& db, const LIST& params, modified_solid* in)
+{
+    size_t base = GenericFill(db, params, static_cast<solid_model*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to modified_solid"); }    do { // convert the 'rationale' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::modified_solid, 2>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->rationale, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to modified_solid to be a `text`")); }
+    } while (0);
+    do { // convert the 'base_solid' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::modified_solid, 2>::aux_is_derived[1] = true; break; }
+        try { GenericConvert(in->base_solid, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to modified_solid to be a `base_solid_select`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<shelled_solid>(const DB& db, const LIST& params, shelled_solid* in)
+{
+    size_t base = GenericFill(db, params, static_cast<modified_solid*>(in));
+    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to shelled_solid"); }    do { // convert the 'deleted_face_set' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::shelled_solid, 2>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->deleted_face_set, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to shelled_solid to be a `SET [1:?] OF face_surface`")); }
+    } while (0);
+    do { // convert the 'thickness' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::shelled_solid, 2>::aux_is_derived[1] = true; break; }
+        try { GenericConvert(in->thickness, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to shelled_solid to be a `length_measure`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<complex_shelled_solid>(const DB& db, const LIST& params, complex_shelled_solid* in)
+{
+    size_t base = GenericFill(db, params, static_cast<shelled_solid*>(in));
+    if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to complex_shelled_solid"); }    do { // convert the 'thickness_list' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->thickness_list, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to complex_shelled_solid to be a `LIST [1:?] OF length_measure`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<composite_assembly_definition>(const DB& db, const LIST& params, composite_assembly_definition* in)
+{
+    size_t base = GenericFill(db, params, static_cast<product_definition*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to composite_assembly_definition"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<composite_assembly_sequence_definition>(const DB& db, const LIST& params, composite_assembly_sequence_definition* in)
+{
+    size_t base = GenericFill(db, params, static_cast<product_definition*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to composite_assembly_sequence_definition"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<laminate_table>(const DB& db, const LIST& params, laminate_table* in)
+{
+    size_t base = GenericFill(db, params, static_cast<product_definition*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to laminate_table"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<part_laminate_table>(const DB& db, const LIST& params, part_laminate_table* in)
+{
+    size_t base = GenericFill(db, params, static_cast<laminate_table*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to part_laminate_table"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<composite_assembly_table>(const DB& db, const LIST& params, composite_assembly_table* in)
+{
+    size_t base = GenericFill(db, params, static_cast<part_laminate_table*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to composite_assembly_table"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<composite_curve_segment>(const DB& db, const LIST& params, composite_curve_segment* in)
+{
+    size_t base = GenericFill(db, params, static_cast<founded_item*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to composite_curve_segment"); }    do { // convert the 'transition' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::composite_curve_segment, 3>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->transition, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to composite_curve_segment to be a `transition_code`")); }
+    } while (0);
+    do { // convert the 'same_sense' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::composite_curve_segment, 3>::aux_is_derived[1] = true; break; }
+        try { GenericConvert(in->same_sense, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to composite_curve_segment to be a `BOOLEAN`")); }
+    } while (0);
+    do { // convert the 'parent_curve' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::composite_curve_segment, 3>::aux_is_derived[2] = true; break; }
+        try { GenericConvert(in->parent_curve, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to composite_curve_segment to be a `curve`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<material_designation>(const DB& db, const LIST& params, material_designation* in)
+{
+    size_t base = 0;
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to material_designation"); }    do { // convert the 'name' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::material_designation, 2>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->name, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to material_designation to be a `label`")); }
+    } while (0);
+    do { // convert the 'definitions' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::material_designation, 2>::aux_is_derived[1] = true; break; }
+        try { GenericConvert(in->definitions, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to material_designation to be a `SET [1:?] OF characterized_definition`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<composite_material_designation>(const DB& db, const LIST& params, composite_material_designation* in)
+{
+    size_t base = GenericFill(db, params, static_cast<material_designation*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to composite_material_designation"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<composite_shape_aspect>(const DB& db, const LIST& params, composite_shape_aspect* in)
+{
+    size_t base = GenericFill(db, params, static_cast<shape_aspect*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to composite_shape_aspect"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<composite_sheet_representation>(const DB& db, const LIST& params, composite_sheet_representation* in)
+{
+    size_t base = GenericFill(db, params, static_cast<shape_representation*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to composite_sheet_representation"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<composite_text>(const DB& db, const LIST& params, composite_text* in)
+{
+    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to composite_text"); }    do { // convert the 'collected_text' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::composite_text, 1>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->collected_text, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to composite_text to be a `SET [2:?] OF text_or_character`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<composite_text_with_associated_curves>(const DB& db, const LIST& params, composite_text_with_associated_curves* in)
+{
+    size_t base = GenericFill(db, params, static_cast<composite_text*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to composite_text_with_associated_curves"); }    do { // convert the 'associated_curves' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->associated_curves, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to composite_text_with_associated_curves to be a `SET [1:?] OF curve`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<composite_text_with_blanking_box>(const DB& db, const LIST& params, composite_text_with_blanking_box* in)
+{
+    size_t base = GenericFill(db, params, static_cast<composite_text*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to composite_text_with_blanking_box"); }    do { // convert the 'blanking' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->blanking, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to composite_text_with_blanking_box to be a `planar_box`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<composite_text_with_delineation>(const DB& db, const LIST& params, composite_text_with_delineation* in)
+{
+    size_t base = GenericFill(db, params, static_cast<composite_text*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to composite_text_with_delineation"); }    do { // convert the 'delineation' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->delineation, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to composite_text_with_delineation to be a `text_delineation`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<composite_text_with_extent>(const DB& db, const LIST& params, composite_text_with_extent* in)
+{
+    size_t base = GenericFill(db, params, static_cast<composite_text*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to composite_text_with_extent"); }    do { // convert the 'extent' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->extent, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to composite_text_with_extent to be a `planar_extent`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<compound_shape_representation>(const DB& db, const LIST& params, compound_shape_representation* in)
+{
+    size_t base = GenericFill(db, params, static_cast<shape_representation*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to compound_shape_representation"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<concentricity_tolerance>(const DB& db, const LIST& params, concentricity_tolerance* in)
+{
+    size_t base = GenericFill(db, params, static_cast<geometric_tolerance_with_datum_reference*>(in));
+    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to concentricity_tolerance"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<concept_feature_relationship>(const DB& db, const LIST& params, concept_feature_relationship* in)
+{
+    size_t base = 0;
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to concept_feature_relationship"); }    do { // convert the 'name' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::concept_feature_relationship, 4>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->name, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to concept_feature_relationship to be a `label`")); }
+    } while (0);
+    do { // convert the 'description' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::concept_feature_relationship, 4>::aux_is_derived[1] = true; break; }
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert(in->description, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to concept_feature_relationship to be a `text`")); }
+    } while (0);
+    do { // convert the 'relating_product_concept_feature' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::concept_feature_relationship, 4>::aux_is_derived[2] = true; break; }
+        try { GenericConvert(in->relating_product_concept_feature, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to concept_feature_relationship to be a `product_concept_feature`")); }
+    } while (0);
+    do { // convert the 'related_product_concept_feature' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::concept_feature_relationship, 4>::aux_is_derived[3] = true; break; }
+        try { GenericConvert(in->related_product_concept_feature, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to concept_feature_relationship to be a `product_concept_feature`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<concept_feature_relationship_with_condition>(const DB& db, const LIST& params, concept_feature_relationship_with_condition* in)
+{
+    size_t base = GenericFill(db, params, static_cast<concept_feature_relationship*>(in));
+    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to concept_feature_relationship_with_condition"); }    do { // convert the 'conditional_operator' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->conditional_operator, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to concept_feature_relationship_with_condition to be a `concept_feature_operator`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<product_concept_feature>(const DB& db, const LIST& params, product_concept_feature* in)
+{
+    size_t base = 0;
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to product_concept_feature"); }    do { // convert the 'id' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::product_concept_feature, 3>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->id, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to product_concept_feature to be a `identifier`")); }
+    } while (0);
+    do { // convert the 'name' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::product_concept_feature, 3>::aux_is_derived[1] = true; break; }
+        try { GenericConvert(in->name, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to product_concept_feature to be a `label`")); }
+    } while (0);
+    do { // convert the 'description' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::product_concept_feature, 3>::aux_is_derived[2] = true; break; }
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert(in->description, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to product_concept_feature to be a `text`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<conditional_concept_feature>(const DB& db, const LIST& params, conditional_concept_feature* in)
+{
+    size_t base = GenericFill(db, params, static_cast<product_concept_feature*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to conditional_concept_feature"); }    do { // convert the 'condition' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::conditional_concept_feature, 1>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->condition, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to conditional_concept_feature to be a `concept_feature_relationship_with_condition`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<conductance_measure_with_unit>(const DB& db, const LIST& params, conductance_measure_with_unit* in)
+{
+    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to conductance_measure_with_unit"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<conductance_unit>(const DB& db, const LIST& params, conductance_unit* in)
+{
+    size_t base = GenericFill(db, params, static_cast<derived_unit*>(in));
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to conductance_unit"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<configuration_item>(const DB& db, const LIST& params, configuration_item* in)
+{
+    size_t base = 0;
+    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to configuration_item"); }    do { // convert the 'id' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::configuration_item, 5>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->id, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to configuration_item to be a `identifier`")); }
+    } while (0);
+    do { // convert the 'name' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::configuration_item, 5>::aux_is_derived[1] = true; break; }
+        try { GenericConvert(in->name, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to configuration_item to be a `label`")); }
+    } while (0);
+    do { // convert the 'description' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::configuration_item, 5>::aux_is_derived[2] = true; break; }
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert(in->description, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to configuration_item to be a `text`")); }
+    } while (0);
+    do { // convert the 'item_concept' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::configuration_item, 5>::aux_is_derived[3] = true; break; }
+        try { GenericConvert(in->item_concept, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to configuration_item to be a `product_concept`")); }
+    } while (0);
+    do { // convert the 'purpose' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::configuration_item, 5>::aux_is_derived[4] = true; break; }
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert(in->purpose, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to configuration_item to be a `label`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<configurable_item>(const DB& db, const LIST& params, configurable_item* in)
+{
+    size_t base = GenericFill(db, params, static_cast<configuration_item*>(in));
+    if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to configurable_item"); }    do { // convert the 'item_concept_feature' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->item_concept_feature, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to configurable_item to be a `SET [1:?] OF product_concept_feature_association`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<effectivity>(const DB& db, const LIST& params, effectivity* in)
+{
+    size_t base = 0;
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to effectivity"); }    do { // convert the 'id' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::effectivity, 1>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->id, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to effectivity to be a `identifier`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<product_definition_effectivity>(const DB& db, const LIST& params, product_definition_effectivity* in)
+{
+    size_t base = GenericFill(db, params, static_cast<effectivity*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to product_definition_effectivity"); }    do { // convert the 'usage' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::product_definition_effectivity, 1>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->usage, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to product_definition_effectivity to be a `product_definition_relationship`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<configuration_effectivity>(const DB& db, const LIST& params, configuration_effectivity* in)
+{
+    size_t base = GenericFill(db, params, static_cast<product_definition_effectivity*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to configuration_effectivity"); }    do { // convert the 'configuration' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->configuration, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to configuration_effectivity to be a `configuration_design`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<configuration_item_relationship>(const DB& db, const LIST& params, configuration_item_relationship* in)
+{
+    size_t base = 0;
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to configuration_item_relationship"); }    do { // convert the 'name' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::configuration_item_relationship, 4>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->name, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to configuration_item_relationship to be a `label`")); }
+    } while (0);
+    do { // convert the 'description' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::configuration_item_relationship, 4>::aux_is_derived[1] = true; break; }
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert(in->description, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to configuration_item_relationship to be a `text`")); }
+    } while (0);
+    do { // convert the 'relating_configuration_item' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::configuration_item_relationship, 4>::aux_is_derived[2] = true; break; }
+        try { GenericConvert(in->relating_configuration_item, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to configuration_item_relationship to be a `configuration_item`")); }
+    } while (0);
+    do { // convert the 'related_configuration_item' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::configuration_item_relationship, 4>::aux_is_derived[3] = true; break; }
+        try { GenericConvert(in->related_configuration_item, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to configuration_item_relationship to be a `configuration_item`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<configuration_item_hierarchical_relationship>(const DB& db, const LIST& params, configuration_item_hierarchical_relationship* in)
+{
+    size_t base = GenericFill(db, params, static_cast<configuration_item_relationship*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to configuration_item_hierarchical_relationship"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<configuration_item_revision_sequence>(const DB& db, const LIST& params, configuration_item_revision_sequence* in)
+{
+    size_t base = GenericFill(db, params, static_cast<configuration_item_relationship*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to configuration_item_revision_sequence"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<configured_effectivity_assignment>(const DB& db, const LIST& params, configured_effectivity_assignment* in)
+{
+    size_t base = GenericFill(db, params, static_cast<effectivity_assignment*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to configured_effectivity_assignment"); }    do { // convert the 'items' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->items, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to configured_effectivity_assignment to be a `SET [1:?] OF configured_effectivity_item`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<configured_effectivity_context_assignment>(const DB& db, const LIST& params, configured_effectivity_context_assignment* in)
+{
+    size_t base = GenericFill(db, params, static_cast<effectivity_context_assignment*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to configured_effectivity_context_assignment"); }    do { // convert the 'items' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->items, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to configured_effectivity_context_assignment to be a `SET [1:?] OF configured_effectivity_context_item`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<conical_stepped_hole_transition>(const DB& db, const LIST& params, conical_stepped_hole_transition* in)
+{
+    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to conical_stepped_hole_transition"); }    do { // convert the 'transition_number' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->transition_number, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to conical_stepped_hole_transition to be a `positive_integer`")); }
+    } while (0);
+    do { // convert the 'cone_apex_angle' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->cone_apex_angle, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to conical_stepped_hole_transition to be a `plane_angle_measure`")); }
+    } while (0);
+    do { // convert the 'cone_base_radius' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->cone_base_radius, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to conical_stepped_hole_transition to be a `positive_length_measure`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<elementary_surface>(const DB& db, const LIST& params, elementary_surface* in)
+{
+    size_t base = GenericFill(db, params, static_cast<surface*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to elementary_surface"); }    do { // convert the 'position' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::elementary_surface, 1>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->position, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to elementary_surface to be a `axis2_placement_3d`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<conical_surface>(const DB& db, const LIST& params, conical_surface* in)
+{
+    size_t base = GenericFill(db, params, static_cast<elementary_surface*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to conical_surface"); }    do { // convert the 'radius' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->radius, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to conical_surface to be a `length_measure`")); }
+    } while (0);
+    do { // convert the 'semi_angle' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->semi_angle, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to conical_surface to be a `plane_angle_measure`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<connected_edge_set>(const DB& db, const LIST& params, connected_edge_set* in)
+{
+    size_t base = GenericFill(db, params, static_cast<topological_representation_item*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to connected_edge_set"); }    do { // convert the 'ces_edges' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->ces_edges, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to connected_edge_set to be a `SET [1:?] OF edge`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<connected_face_sub_set>(const DB& db, const LIST& params, connected_face_sub_set* in)
+{
+    size_t base = GenericFill(db, params, static_cast<connected_face_set*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to connected_face_sub_set"); }    do { // convert the 'parent_face_set' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->parent_face_set, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to connected_face_sub_set to be a `connected_face_set`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<constructive_geometry_representation>(const DB& db, const LIST& params, constructive_geometry_representation* in)
+{
+    size_t base = GenericFill(db, params, static_cast<representation*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to constructive_geometry_representation"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<representation_relationship>(const DB& db, const LIST& params, representation_relationship* in)
+{
+    size_t base = 0;
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to representation_relationship"); }    do { // convert the 'name' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::representation_relationship, 4>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->name, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to representation_relationship to be a `label`")); }
+    } while (0);
+    do { // convert the 'description' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::representation_relationship, 4>::aux_is_derived[1] = true; break; }
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert(in->description, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to representation_relationship to be a `text`")); }
+    } while (0);
+    do { // convert the 'rep_1' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::representation_relationship, 4>::aux_is_derived[2] = true; break; }
+        try { GenericConvert(in->rep_1, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to representation_relationship to be a `representation`")); }
+    } while (0);
+    do { // convert the 'rep_2' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::representation_relationship, 4>::aux_is_derived[3] = true; break; }
+        try { GenericConvert(in->rep_2, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to representation_relationship to be a `representation`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<constructive_geometry_representation_relationship>(const DB& db, const LIST& params, constructive_geometry_representation_relationship* in)
+{
+    size_t base = GenericFill(db, params, static_cast<representation_relationship*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to constructive_geometry_representation_relationship"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<contact_ratio_representation>(const DB& db, const LIST& params, contact_ratio_representation* in)
+{
+    size_t base = GenericFill(db, params, static_cast<representation*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to contact_ratio_representation"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<invisibility>(const DB& db, const LIST& params, invisibility* in)
+{
+    size_t base = 0;
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to invisibility"); }    do { // convert the 'invisible_items' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::invisibility, 1>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->invisible_items, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to invisibility to be a `SET [1:?] OF invisible_item`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<context_dependent_invisibility>(const DB& db, const LIST& params, context_dependent_invisibility* in)
+{
+    size_t base = GenericFill(db, params, static_cast<invisibility*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to context_dependent_invisibility"); }    do { // convert the 'presentation_context' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->presentation_context, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to context_dependent_invisibility to be a `invisibility_context`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<over_riding_styled_item>(const DB& db, const LIST& params, over_riding_styled_item* in)
+{
+    size_t base = GenericFill(db, params, static_cast<styled_item*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to over_riding_styled_item"); }    do { // convert the 'over_ridden_style' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::over_riding_styled_item, 1>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->over_ridden_style, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to over_riding_styled_item to be a `styled_item`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<context_dependent_over_riding_styled_item>(const DB& db, const LIST& params, context_dependent_over_riding_styled_item* in)
+{
+    size_t base = GenericFill(db, params, static_cast<over_riding_styled_item*>(in));
+    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to context_dependent_over_riding_styled_item"); }    do { // convert the 'style_context' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::context_dependent_over_riding_styled_item, 1>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->style_context, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to context_dependent_over_riding_styled_item to be a `LIST [1:?] OF style_context_select`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<context_dependent_unit>(const DB& db, const LIST& params, context_dependent_unit* in)
+{
+    size_t base = GenericFill(db, params, static_cast<named_unit*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to context_dependent_unit"); }    do { // convert the 'name' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::context_dependent_unit, 1>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->name, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to context_dependent_unit to be a `label`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<conversion_based_unit>(const DB& db, const LIST& params, conversion_based_unit* in)
+{
+    size_t base = GenericFill(db, params, static_cast<named_unit*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to conversion_based_unit"); }    do { // convert the 'name' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->name, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to conversion_based_unit to be a `label`")); }
+    } while (0);
+    do { // convert the 'conversion_factor' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->conversion_factor, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to conversion_based_unit to be a `measure_with_unit`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<csg_shape_representation>(const DB& db, const LIST& params, csg_shape_representation* in)
+{
+    size_t base = GenericFill(db, params, static_cast<shape_representation*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to csg_shape_representation"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<csg_solid>(const DB& db, const LIST& params, csg_solid* in)
+{
+    size_t base = GenericFill(db, params, static_cast<solid_model*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to csg_solid"); }    do { // convert the 'tree_root_expression' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->tree_root_expression, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to csg_solid to be a `csg_select`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<currency>(const DB& db, const LIST& params, currency* in)
+{
+    size_t base = GenericFill(db, params, static_cast<context_dependent_unit*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to currency"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<currency_measure_with_unit>(const DB& db, const LIST& params, currency_measure_with_unit* in)
+{
+    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to currency_measure_with_unit"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<curve_bounded_surface>(const DB& db, const LIST& params, curve_bounded_surface* in)
+{
+    size_t base = GenericFill(db, params, static_cast<bounded_surface*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to curve_bounded_surface"); }    do { // convert the 'basis_surface' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->basis_surface, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to curve_bounded_surface to be a `surface`")); }
+    } while (0);
+    do { // convert the 'boundaries' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->boundaries, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to curve_bounded_surface to be a `SET [1:?] OF boundary_curve`")); }
+    } while (0);
+    do { // convert the 'implicit_outer' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->implicit_outer, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to curve_bounded_surface to be a `BOOLEAN`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<curve_dimension>(const DB& db, const LIST& params, curve_dimension* in)
+{
+    size_t base = GenericFill(db, params, static_cast<dimension_curve_directed_callout*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to curve_dimension"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<curve_replica>(const DB& db, const LIST& params, curve_replica* in)
+{
+    size_t base = GenericFill(db, params, static_cast<curve*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to curve_replica"); }    do { // convert the 'parent_curve' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->parent_curve, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to curve_replica to be a `curve`")); }
+    } while (0);
+    do { // convert the 'transformation' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->transformation, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to curve_replica to be a `cartesian_transformation_operator`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<curve_style>(const DB& db, const LIST& params, curve_style* in)
+{
+    size_t base = GenericFill(db, params, static_cast<founded_item*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to curve_style"); }    do { // convert the 'name' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->name, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to curve_style to be a `label`")); }
+    } while (0);
+    do { // convert the 'curve_font' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->curve_font, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to curve_style to be a `curve_font_or_scaled_curve_font_select`")); }
+    } while (0);
+    do { // convert the 'curve_width' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->curve_width, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to curve_style to be a `size_select`")); }
+    } while (0);
+    do { // convert the 'curve_colour' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->curve_colour, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to curve_style to be a `colour`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<curve_style_font>(const DB& db, const LIST& params, curve_style_font* in)
+{
+    size_t base = GenericFill(db, params, static_cast<founded_item*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to curve_style_font"); }    do { // convert the 'name' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->name, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to curve_style_font to be a `label`")); }
+    } while (0);
+    do { // convert the 'pattern_list' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->pattern_list, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to curve_style_font to be a `LIST [1:?] OF curve_style_font_pattern`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<curve_style_font_and_scaling>(const DB& db, const LIST& params, curve_style_font_and_scaling* in)
+{
+    size_t base = GenericFill(db, params, static_cast<founded_item*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to curve_style_font_and_scaling"); }    do { // convert the 'name' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->name, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to curve_style_font_and_scaling to be a `label`")); }
+    } while (0);
+    do { // convert the 'curve_font' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->curve_font, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to curve_style_font_and_scaling to be a `curve_style_font_select`")); }
+    } while (0);
+    do { // convert the 'curve_font_scaling' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->curve_font_scaling, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to curve_style_font_and_scaling to be a `REAL`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<curve_style_font_pattern>(const DB& db, const LIST& params, curve_style_font_pattern* in)
+{
+    size_t base = GenericFill(db, params, static_cast<founded_item*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to curve_style_font_pattern"); }    do { // convert the 'visible_segment_length' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->visible_segment_length, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to curve_style_font_pattern to be a `positive_length_measure`")); }
+    } while (0);
+    do { // convert the 'invisible_segment_length' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->invisible_segment_length, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to curve_style_font_pattern to be a `positive_length_measure`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<curve_swept_solid_shape_representation>(const DB& db, const LIST& params, curve_swept_solid_shape_representation* in)
+{
+    size_t base = GenericFill(db, params, static_cast<shape_representation*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to curve_swept_solid_shape_representation"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<cylindrical_surface>(const DB& db, const LIST& params, cylindrical_surface* in)
+{
+    size_t base = GenericFill(db, params, static_cast<elementary_surface*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to cylindrical_surface"); }    do { // convert the 'radius' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->radius, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to cylindrical_surface to be a `positive_length_measure`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<cylindricity_tolerance>(const DB& db, const LIST& params, cylindricity_tolerance* in)
+{
+    size_t base = GenericFill(db, params, static_cast<geometric_tolerance*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to cylindricity_tolerance"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<date_representation_item>(const DB& db, const LIST& params, date_representation_item* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<date_time_representation_item>(const DB& db, const LIST& params, date_time_representation_item* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<dated_effectivity>(const DB& db, const LIST& params, dated_effectivity* in)
+{
+    size_t base = GenericFill(db, params, static_cast<effectivity*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to dated_effectivity"); }    do { // convert the 'effectivity_end_date' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert(in->effectivity_end_date, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to dated_effectivity to be a `date_time_or_event_occurrence`")); }
+    } while (0);
+    do { // convert the 'effectivity_start_date' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->effectivity_start_date, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to dated_effectivity to be a `date_time_or_event_occurrence`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<datum>(const DB& db, const LIST& params, datum* in)
+{
+    size_t base = GenericFill(db, params, static_cast<shape_aspect*>(in));
+    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to datum"); }    do { // convert the 'identification' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->identification, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to datum to be a `identifier`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<datum_feature>(const DB& db, const LIST& params, datum_feature* in)
+{
+    size_t base = GenericFill(db, params, static_cast<shape_aspect*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to datum_feature"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<datum_feature_callout>(const DB& db, const LIST& params, datum_feature_callout* in)
+{
+    size_t base = GenericFill(db, params, static_cast<draughting_callout*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to datum_feature_callout"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<datum_reference>(const DB& db, const LIST& params, datum_reference* in)
+{
+    size_t base = 0;
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to datum_reference"); }    do { // convert the 'precedence' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::datum_reference, 2>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->precedence, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to datum_reference to be a `INTEGER`")); }
+    } while (0);
+    do { // convert the 'referenced_datum' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::datum_reference, 2>::aux_is_derived[1] = true; break; }
+        try { GenericConvert(in->referenced_datum, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to datum_reference to be a `datum`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<datum_target>(const DB& db, const LIST& params, datum_target* in)
+{
+    size_t base = GenericFill(db, params, static_cast<shape_aspect*>(in));
+    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to datum_target"); }    do { // convert the 'target_id' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::datum_target, 1>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->target_id, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to datum_target to be a `identifier`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<datum_target_callout>(const DB& db, const LIST& params, datum_target_callout* in)
+{
+    size_t base = GenericFill(db, params, static_cast<draughting_callout*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to datum_target_callout"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<default_tolerance_table>(const DB& db, const LIST& params, default_tolerance_table* in)
+{
+    size_t base = GenericFill(db, params, static_cast<representation*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to default_tolerance_table"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<default_tolerance_table_cell>(const DB& db, const LIST& params, default_tolerance_table_cell* in)
+{
+    size_t base = GenericFill(db, params, static_cast<compound_representation_item*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to default_tolerance_table_cell"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<defined_symbol>(const DB& db, const LIST& params, defined_symbol* in)
+{
+    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to defined_symbol"); }    do { // convert the 'definition' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->definition, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to defined_symbol to be a `defined_symbol_select`")); }
+    } while (0);
+    do { // convert the 'target' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->target, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to defined_symbol to be a `symbol_target`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<definitional_representation>(const DB& db, const LIST& params, definitional_representation* in)
+{
+    size_t base = GenericFill(db, params, static_cast<representation*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to definitional_representation"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<definitional_representation_relationship>(const DB& db, const LIST& params, definitional_representation_relationship* in)
+{
+    size_t base = GenericFill(db, params, static_cast<representation_relationship*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to definitional_representation_relationship"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<definitional_representation_relationship_with_same_context>(const DB& db, const LIST& params, definitional_representation_relationship_with_same_context* in)
+{
+    size_t base = GenericFill(db, params, static_cast<definitional_representation_relationship*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to definitional_representation_relationship_with_same_context"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<degenerate_pcurve>(const DB& db, const LIST& params, degenerate_pcurve* in)
+{
+    size_t base = GenericFill(db, params, static_cast<point*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to degenerate_pcurve"); }    do { // convert the 'basis_surface' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::degenerate_pcurve, 2>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->basis_surface, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to degenerate_pcurve to be a `surface`")); }
+    } while (0);
+    do { // convert the 'reference_to_curve' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::degenerate_pcurve, 2>::aux_is_derived[1] = true; break; }
+        try { GenericConvert(in->reference_to_curve, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to degenerate_pcurve to be a `definitional_representation`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<toroidal_surface>(const DB& db, const LIST& params, toroidal_surface* in)
+{
+    size_t base = GenericFill(db, params, static_cast<elementary_surface*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to toroidal_surface"); }    do { // convert the 'major_radius' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::toroidal_surface, 2>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->major_radius, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to toroidal_surface to be a `positive_length_measure`")); }
+    } while (0);
+    do { // convert the 'minor_radius' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::toroidal_surface, 2>::aux_is_derived[1] = true; break; }
+        try { GenericConvert(in->minor_radius, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to toroidal_surface to be a `positive_length_measure`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<degenerate_toroidal_surface>(const DB& db, const LIST& params, degenerate_toroidal_surface* in)
+{
+    size_t base = GenericFill(db, params, static_cast<toroidal_surface*>(in));
+    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to degenerate_toroidal_surface"); }    do { // convert the 'select_outer' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->select_outer, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to degenerate_toroidal_surface to be a `BOOLEAN`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<descriptive_representation_item>(const DB& db, const LIST& params, descriptive_representation_item* in)
+{
+    size_t base = GenericFill(db, params, static_cast<representation_item*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to descriptive_representation_item"); }    do { // convert the 'description' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::descriptive_representation_item, 1>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->description, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to descriptive_representation_item to be a `text`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<product_definition_context>(const DB& db, const LIST& params, product_definition_context* in)
+{
+    size_t base = GenericFill(db, params, static_cast<application_context_element*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to product_definition_context"); }    do { // convert the 'life_cycle_stage' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::product_definition_context, 1>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->life_cycle_stage, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to product_definition_context to be a `label`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<design_context>(const DB& db, const LIST& params, design_context* in)
+{
+    size_t base = GenericFill(db, params, static_cast<product_definition_context*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to design_context"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<design_make_from_relationship>(const DB& db, const LIST& params, design_make_from_relationship* in)
+{
+    size_t base = GenericFill(db, params, static_cast<product_definition_relationship*>(in));
+    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to design_make_from_relationship"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<diameter_dimension>(const DB& db, const LIST& params, diameter_dimension* in)
+{
+    size_t base = GenericFill(db, params, static_cast<dimension_curve_directed_callout*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to diameter_dimension"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<ratio_measure_with_unit>(const DB& db, const LIST& params, ratio_measure_with_unit* in)
+{
+    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to ratio_measure_with_unit"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<dielectric_constant_measure_with_unit>(const DB& db, const LIST& params, dielectric_constant_measure_with_unit* in)
+{
+    size_t base = GenericFill(db, params, static_cast<ratio_measure_with_unit*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to dielectric_constant_measure_with_unit"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<dimension_callout>(const DB& db, const LIST& params, dimension_callout* in)
+{
+    size_t base = GenericFill(db, params, static_cast<draughting_callout*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to dimension_callout"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<draughting_callout_relationship>(const DB& db, const LIST& params, draughting_callout_relationship* in)
+{
+    size_t base = 0;
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to draughting_callout_relationship"); }    do { // convert the 'name' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::draughting_callout_relationship, 4>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->name, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to draughting_callout_relationship to be a `label`")); }
+    } while (0);
+    do { // convert the 'description' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::draughting_callout_relationship, 4>::aux_is_derived[1] = true; break; }
+        try { GenericConvert(in->description, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to draughting_callout_relationship to be a `text`")); }
+    } while (0);
+    do { // convert the 'relating_draughting_callout' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::draughting_callout_relationship, 4>::aux_is_derived[2] = true; break; }
+        try { GenericConvert(in->relating_draughting_callout, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to draughting_callout_relationship to be a `draughting_callout`")); }
+    } while (0);
+    do { // convert the 'related_draughting_callout' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::draughting_callout_relationship, 4>::aux_is_derived[3] = true; break; }
+        try { GenericConvert(in->related_draughting_callout, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to draughting_callout_relationship to be a `draughting_callout`")); }
+    } while (0);
+    return base;
+}
+
+}
+}

code/Importer/StepFile/StepFileGen3.cpp

@@ -0,0 +1,5746 @@
+/*
+Open Asset Import Library (ASSIMP)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2010, ASSIMP Development Team
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the ASSIMP team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the ASSIMP Development Team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+#include "code/Importer/StepFile/StepReaderGen.h"
+
+namespace Assimp {
+using namespace StepFile;
+namespace STEP {
+
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<dimension_callout_component_relationship>(const DB& db, const LIST& params, dimension_callout_component_relationship* in)
+{
+    size_t base = GenericFill(db, params, static_cast<draughting_callout_relationship*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to dimension_callout_component_relationship"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<dimension_callout_relationship>(const DB& db, const LIST& params, dimension_callout_relationship* in)
+{
+    size_t base = GenericFill(db, params, static_cast<draughting_callout_relationship*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to dimension_callout_relationship"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<dimension_curve>(const DB& db, const LIST& params, dimension_curve* in)
+{
+    size_t base = GenericFill(db, params, static_cast<annotation_curve_occurrence*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to dimension_curve"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<terminator_symbol>(const DB& db, const LIST& params, terminator_symbol* in)
+{
+    size_t base = GenericFill(db, params, static_cast<annotation_symbol_occurrence*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to terminator_symbol"); }    do { // convert the 'annotated_curve' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::terminator_symbol, 1>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->annotated_curve, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to terminator_symbol to be a `annotation_curve_occurrence`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<dimension_curve_terminator>(const DB& db, const LIST& params, dimension_curve_terminator* in)
+{
+    size_t base = GenericFill(db, params, static_cast<terminator_symbol*>(in));
+    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to dimension_curve_terminator"); }    do { // convert the 'role' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->role, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to dimension_curve_terminator to be a `dimension_extent_usage`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<dimension_curve_terminator_to_projection_curve_associativity>(const DB& db, const LIST& params, dimension_curve_terminator_to_projection_curve_associativity* in)
+{
+    size_t base = GenericFill(db, params, static_cast<annotation_occurrence_associativity*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to dimension_curve_terminator_to_projection_curve_associativity"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<dimension_pair>(const DB& db, const LIST& params, dimension_pair* in)
+{
+    size_t base = GenericFill(db, params, static_cast<draughting_callout_relationship*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to dimension_pair"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<dimension_text_associativity>(const DB& db, const LIST& params, dimension_text_associativity* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<dimensional_location_with_path>(const DB& db, const LIST& params, dimensional_location_with_path* in)
+{
+    size_t base = GenericFill(db, params, static_cast<dimensional_location*>(in));
+    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to dimensional_location_with_path"); }    do { // convert the 'path' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->path, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to dimensional_location_with_path to be a `shape_aspect`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<dimensional_size_with_path>(const DB& db, const LIST& params, dimensional_size_with_path* in)
+{
+    size_t base = GenericFill(db, params, static_cast<dimensional_size*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to dimensional_size_with_path"); }    do { // convert the 'path' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->path, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to dimensional_size_with_path to be a `shape_aspect`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<executed_action>(const DB& db, const LIST& params, executed_action* in)
+{
+    size_t base = GenericFill(db, params, static_cast<action*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to executed_action"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<directed_action>(const DB& db, const LIST& params, directed_action* in)
+{
+    size_t base = GenericFill(db, params, static_cast<executed_action*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to directed_action"); }    do { // convert the 'directive' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->directive, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to directed_action to be a `action_directive`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<directed_dimensional_location>(const DB& db, const LIST& params, directed_dimensional_location* in)
+{
+    size_t base = GenericFill(db, params, static_cast<dimensional_location*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to directed_dimensional_location"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<direction>(const DB& db, const LIST& params, direction* in)
+{
+    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to direction"); }    do { // convert the 'direction_ratios' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->direction_ratios, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to direction to be a `LIST [2:3] OF REAL`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<document_file>(const DB& db, const LIST& params, document_file* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<document_identifier>(const DB& db, const LIST& params, document_identifier* in)
+{
+    size_t base = GenericFill(db, params, static_cast<group*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to document_identifier"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<document_identifier_assignment>(const DB& db, const LIST& params, document_identifier_assignment* in)
+{
+    size_t base = GenericFill(db, params, static_cast<group_assignment*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to document_identifier_assignment"); }    do { // convert the 'items' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->items, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to document_identifier_assignment to be a `SET [1:?] OF document_identifier_assigned_item`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<document_product_association>(const DB& db, const LIST& params, document_product_association* in)
+{
+    size_t base = 0;
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to document_product_association"); }    do { // convert the 'name' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::document_product_association, 4>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->name, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to document_product_association to be a `label`")); }
+    } while (0);
+    do { // convert the 'description' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::document_product_association, 4>::aux_is_derived[1] = true; break; }
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert(in->description, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to document_product_association to be a `text`")); }
+    } while (0);
+    do { // convert the 'relating_document' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::document_product_association, 4>::aux_is_derived[2] = true; break; }
+        try { GenericConvert(in->relating_document, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to document_product_association to be a `document`")); }
+    } while (0);
+    do { // convert the 'related_product' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::document_product_association, 4>::aux_is_derived[3] = true; break; }
+        try { GenericConvert(in->related_product, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to document_product_association to be a `product_or_formation_or_definition`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<document_product_equivalence>(const DB& db, const LIST& params, document_product_equivalence* in)
+{
+    size_t base = GenericFill(db, params, static_cast<document_product_association*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to document_product_equivalence"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<dose_equivalent_measure_with_unit>(const DB& db, const LIST& params, dose_equivalent_measure_with_unit* in)
+{
+    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to dose_equivalent_measure_with_unit"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<dose_equivalent_unit>(const DB& db, const LIST& params, dose_equivalent_unit* in)
+{
+    size_t base = GenericFill(db, params, static_cast<derived_unit*>(in));
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to dose_equivalent_unit"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<double_offset_shelled_solid>(const DB& db, const LIST& params, double_offset_shelled_solid* in)
+{
+    size_t base = GenericFill(db, params, static_cast<shelled_solid*>(in));
+    if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to double_offset_shelled_solid"); }    do { // convert the 'thickness2' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->thickness2, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to double_offset_shelled_solid to be a `length_measure`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<item_defined_transformation>(const DB& db, const LIST& params, item_defined_transformation* in)
+{
+    size_t base = 0;
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to item_defined_transformation"); }    do { // convert the 'name' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::item_defined_transformation, 4>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->name, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to item_defined_transformation to be a `label`")); }
+    } while (0);
+    do { // convert the 'description' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::item_defined_transformation, 4>::aux_is_derived[1] = true; break; }
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert(in->description, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to item_defined_transformation to be a `text`")); }
+    } while (0);
+    do { // convert the 'transform_item_1' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::item_defined_transformation, 4>::aux_is_derived[2] = true; break; }
+        try { GenericConvert(in->transform_item_1, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to item_defined_transformation to be a `representation_item`")); }
+    } while (0);
+    do { // convert the 'transform_item_2' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::item_defined_transformation, 4>::aux_is_derived[3] = true; break; }
+        try { GenericConvert(in->transform_item_2, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to item_defined_transformation to be a `representation_item`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<transformation_with_derived_angle>(const DB& db, const LIST& params, transformation_with_derived_angle* in)
+{
+    size_t base = GenericFill(db, params, static_cast<item_defined_transformation*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to transformation_with_derived_angle"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<draped_defined_transformation>(const DB& db, const LIST& params, draped_defined_transformation* in)
+{
+    size_t base = GenericFill(db, params, static_cast<transformation_with_derived_angle*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to draped_defined_transformation"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<draughting_annotation_occurrence>(const DB& db, const LIST& params, draughting_annotation_occurrence* in)
+{
+    size_t base = GenericFill(db, params, static_cast<annotation_occurrence*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to draughting_annotation_occurrence"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<draughting_elements>(const DB& db, const LIST& params, draughting_elements* in)
+{
+    size_t base = GenericFill(db, params, static_cast<draughting_callout*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to draughting_elements"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<draughting_model>(const DB& db, const LIST& params, draughting_model* in)
+{
+    size_t base = GenericFill(db, params, static_cast<representation*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to draughting_model"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<item_identified_representation_usage>(const DB& db, const LIST& params, item_identified_representation_usage* in)
+{
+    size_t base = 0;
+    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to item_identified_representation_usage"); }    do { // convert the 'name' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::item_identified_representation_usage, 5>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->name, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to item_identified_representation_usage to be a `label`")); }
+    } while (0);
+    do { // convert the 'description' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::item_identified_representation_usage, 5>::aux_is_derived[1] = true; break; }
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert(in->description, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to item_identified_representation_usage to be a `text`")); }
+    } while (0);
+    do { // convert the 'definition' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::item_identified_representation_usage, 5>::aux_is_derived[2] = true; break; }
+        try { GenericConvert(in->definition, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to item_identified_representation_usage to be a `represented_definition`")); }
+    } while (0);
+    do { // convert the 'used_representation' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::item_identified_representation_usage, 5>::aux_is_derived[3] = true; break; }
+        try { GenericConvert(in->used_representation, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to item_identified_representation_usage to be a `representation`")); }
+    } while (0);
+    do { // convert the 'identified_item' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::item_identified_representation_usage, 5>::aux_is_derived[4] = true; break; }
+        try { GenericConvert(in->identified_item, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to item_identified_representation_usage to be a `representation_item`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<draughting_model_item_association>(const DB& db, const LIST& params, draughting_model_item_association* in)
+{
+    size_t base = GenericFill(db, params, static_cast<item_identified_representation_usage*>(in));
+    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to draughting_model_item_association"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<pre_defined_colour>(const DB& db, const LIST& params, pre_defined_colour* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<draughting_pre_defined_colour>(const DB& db, const LIST& params, draughting_pre_defined_colour* in)
+{
+    size_t base = GenericFill(db, params, static_cast<pre_defined_colour*>(in));
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<pre_defined_item>(const DB& db, const LIST& params, pre_defined_item* in)
+{
+    size_t base = 0;
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to pre_defined_item"); }    do { // convert the 'name' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::pre_defined_item, 1>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->name, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to pre_defined_item to be a `label`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<pre_defined_curve_font>(const DB& db, const LIST& params, pre_defined_curve_font* in)
+{
+    size_t base = GenericFill(db, params, static_cast<pre_defined_item*>(in));
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to pre_defined_curve_font"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<draughting_pre_defined_curve_font>(const DB& db, const LIST& params, draughting_pre_defined_curve_font* in)
+{
+    size_t base = GenericFill(db, params, static_cast<pre_defined_curve_font*>(in));
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to draughting_pre_defined_curve_font"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<pre_defined_text_font>(const DB& db, const LIST& params, pre_defined_text_font* in)
+{
+    size_t base = GenericFill(db, params, static_cast<pre_defined_item*>(in));
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to pre_defined_text_font"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<draughting_pre_defined_text_font>(const DB& db, const LIST& params, draughting_pre_defined_text_font* in)
+{
+    size_t base = GenericFill(db, params, static_cast<pre_defined_text_font*>(in));
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to draughting_pre_defined_text_font"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<draughting_subfigure_representation>(const DB& db, const LIST& params, draughting_subfigure_representation* in)
+{
+    size_t base = GenericFill(db, params, static_cast<symbol_representation*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to draughting_subfigure_representation"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<draughting_symbol_representation>(const DB& db, const LIST& params, draughting_symbol_representation* in)
+{
+    size_t base = GenericFill(db, params, static_cast<symbol_representation*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to draughting_symbol_representation"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<text_literal>(const DB& db, const LIST& params, text_literal* in)
+{
+    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
+    if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to text_literal"); }    do { // convert the 'literal' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::text_literal, 5>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->literal, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to text_literal to be a `presentable_text`")); }
+    } while (0);
+    do { // convert the 'placement' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::text_literal, 5>::aux_is_derived[1] = true; break; }
+        try { GenericConvert(in->placement, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to text_literal to be a `axis2_placement`")); }
+    } while (0);
+    do { // convert the 'alignment' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::text_literal, 5>::aux_is_derived[2] = true; break; }
+        try { GenericConvert(in->alignment, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to text_literal to be a `text_alignment`")); }
+    } while (0);
+    do { // convert the 'path' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::text_literal, 5>::aux_is_derived[3] = true; break; }
+        try { GenericConvert(in->path, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to text_literal to be a `text_path`")); }
+    } while (0);
+    do { // convert the 'font' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::text_literal, 5>::aux_is_derived[4] = true; break; }
+        try { GenericConvert(in->font, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to text_literal to be a `font_select`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<text_literal_with_delineation>(const DB& db, const LIST& params, text_literal_with_delineation* in)
+{
+    size_t base = GenericFill(db, params, static_cast<text_literal*>(in));
+    if (params.GetSize() < 7) { throw STEP::TypeError("expected 7 arguments to text_literal_with_delineation"); }    do { // convert the 'delineation' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::text_literal_with_delineation, 1>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->delineation, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to text_literal_with_delineation to be a `text_delineation`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<draughting_text_literal_with_delineation>(const DB& db, const LIST& params, draughting_text_literal_with_delineation* in)
+{
+    size_t base = GenericFill(db, params, static_cast<text_literal_with_delineation*>(in));
+    if (params.GetSize() < 7) { throw STEP::TypeError("expected 7 arguments to draughting_text_literal_with_delineation"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<presentation_set>(const DB& db, const LIST& params, presentation_set* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<drawing_revision>(const DB& db, const LIST& params, drawing_revision* in)
+{
+    size_t base = GenericFill(db, params, static_cast<presentation_set*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to drawing_revision"); }    do { // convert the 'revision_identifier' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->revision_identifier, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to drawing_revision to be a `identifier`")); }
+    } while (0);
+    do { // convert the 'drawing_identifier' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->drawing_identifier, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to drawing_revision to be a `drawing_definition`")); }
+    } while (0);
+    do { // convert the 'intended_scale' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert(in->intended_scale, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to drawing_revision to be a `text`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<presentation_representation>(const DB& db, const LIST& params, presentation_representation* in)
+{
+    size_t base = GenericFill(db, params, static_cast<representation*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to presentation_representation"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<presentation_area>(const DB& db, const LIST& params, presentation_area* in)
+{
+    size_t base = GenericFill(db, params, static_cast<presentation_representation*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to presentation_area"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<drawing_sheet_revision>(const DB& db, const LIST& params, drawing_sheet_revision* in)
+{
+    size_t base = GenericFill(db, params, static_cast<presentation_area*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to drawing_sheet_revision"); }    do { // convert the 'revision_identifier' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->revision_identifier, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to drawing_sheet_revision to be a `identifier`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<drawing_sheet_revision_sequence>(const DB& db, const LIST& params, drawing_sheet_revision_sequence* in)
+{
+    size_t base = GenericFill(db, params, static_cast<representation_relationship*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to drawing_sheet_revision_sequence"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<drawing_sheet_revision_usage>(const DB& db, const LIST& params, drawing_sheet_revision_usage* in)
+{
+    size_t base = GenericFill(db, params, static_cast<area_in_set*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to drawing_sheet_revision_usage"); }    do { // convert the 'sheet_number' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->sheet_number, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to drawing_sheet_revision_usage to be a `identifier`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<edge>(const DB& db, const LIST& params, edge* in)
+{
+    size_t base = GenericFill(db, params, static_cast<topological_representation_item*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to edge"); }    do { // convert the 'edge_start' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::edge, 2>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->edge_start, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to edge to be a `vertex`")); }
+    } while (0);
+    do { // convert the 'edge_end' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::edge, 2>::aux_is_derived[1] = true; break; }
+        try { GenericConvert(in->edge_end, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to edge to be a `vertex`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<edge_based_wireframe_model>(const DB& db, const LIST& params, edge_based_wireframe_model* in)
+{
+    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to edge_based_wireframe_model"); }    do { // convert the 'ebwm_boundary' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->ebwm_boundary, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to edge_based_wireframe_model to be a `SET [1:?] OF connected_edge_set`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<edge_based_wireframe_shape_representation>(const DB& db, const LIST& params, edge_based_wireframe_shape_representation* in)
+{
+    size_t base = GenericFill(db, params, static_cast<shape_representation*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to edge_based_wireframe_shape_representation"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<edge_blended_solid>(const DB& db, const LIST& params, edge_blended_solid* in)
+{
+    size_t base = GenericFill(db, params, static_cast<modified_solid*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to edge_blended_solid"); }    do { // convert the 'blended_edges' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::edge_blended_solid, 1>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->blended_edges, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to edge_blended_solid to be a `LIST [1:?] OF edge_curve`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<edge_curve>(const DB& db, const LIST& params, edge_curve* in)
+{
+    size_t base = 0;
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to edge_curve"); }    do { // convert the 'edge_geometry' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->edge_geometry, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to edge_curve to be a `curve`")); }
+    } while (0);
+    do { // convert the 'same_sense' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->same_sense, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to edge_curve to be a `BOOLEAN`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<edge_loop>(const DB& db, const LIST& params, edge_loop* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<electric_charge_measure_with_unit>(const DB& db, const LIST& params, electric_charge_measure_with_unit* in)
+{
+    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to electric_charge_measure_with_unit"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<electric_charge_unit>(const DB& db, const LIST& params, electric_charge_unit* in)
+{
+    size_t base = GenericFill(db, params, static_cast<derived_unit*>(in));
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to electric_charge_unit"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<electric_current_measure_with_unit>(const DB& db, const LIST& params, electric_current_measure_with_unit* in)
+{
+    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to electric_current_measure_with_unit"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<electric_current_unit>(const DB& db, const LIST& params, electric_current_unit* in)
+{
+    size_t base = GenericFill(db, params, static_cast<named_unit*>(in));
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to electric_current_unit"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<electric_potential_measure_with_unit>(const DB& db, const LIST& params, electric_potential_measure_with_unit* in)
+{
+    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to electric_potential_measure_with_unit"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<electric_potential_unit>(const DB& db, const LIST& params, electric_potential_unit* in)
+{
+    size_t base = GenericFill(db, params, static_cast<derived_unit*>(in));
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to electric_potential_unit"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<elementary_brep_shape_representation>(const DB& db, const LIST& params, elementary_brep_shape_representation* in)
+{
+    size_t base = GenericFill(db, params, static_cast<shape_representation*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to elementary_brep_shape_representation"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<ellipse>(const DB& db, const LIST& params, ellipse* in)
+{
+    size_t base = GenericFill(db, params, static_cast<conic*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to ellipse"); }    do { // convert the 'semi_axis_1' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->semi_axis_1, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to ellipse to be a `positive_length_measure`")); }
+    } while (0);
+    do { // convert the 'semi_axis_2' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->semi_axis_2, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to ellipse to be a `positive_length_measure`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<energy_measure_with_unit>(const DB& db, const LIST& params, energy_measure_with_unit* in)
+{
+    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to energy_measure_with_unit"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<energy_unit>(const DB& db, const LIST& params, energy_unit* in)
+{
+    size_t base = GenericFill(db, params, static_cast<derived_unit*>(in));
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to energy_unit"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<property_definition>(const DB& db, const LIST& params, property_definition* in)
+{
+    size_t base = 0;
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to property_definition"); }    do { // convert the 'name' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::property_definition, 3>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->name, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to property_definition to be a `label`")); }
+    } while (0);
+    do { // convert the 'description' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::property_definition, 3>::aux_is_derived[1] = true; break; }
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert(in->description, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to property_definition to be a `text`")); }
+    } while (0);
+    do { // convert the 'definition' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::property_definition, 3>::aux_is_derived[2] = true; break; }
+        try { GenericConvert(in->definition, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to property_definition to be a `characterized_definition`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<fact_type>(const DB& db, const LIST& params, fact_type* in)
+{
+    size_t base = GenericFill(db, params, static_cast<property_definition*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to fact_type"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<entity_assertion>(const DB& db, const LIST& params, entity_assertion* in)
+{
+    size_t base = GenericFill(db, params, static_cast<fact_type*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to entity_assertion"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<enum_reference_prefix>(const DB& db, const LIST& params, enum_reference_prefix* in)
+{
+    size_t base = GenericFill(db, params, static_cast<descriptive_representation_item*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to enum_reference_prefix"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<evaluated_characteristic>(const DB& db, const LIST& params, evaluated_characteristic* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<evaluated_degenerate_pcurve>(const DB& db, const LIST& params, evaluated_degenerate_pcurve* in)
+{
+    size_t base = GenericFill(db, params, static_cast<degenerate_pcurve*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to evaluated_degenerate_pcurve"); }    do { // convert the 'equivalent_point' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->equivalent_point, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to evaluated_degenerate_pcurve to be a `cartesian_point`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<evaluation_product_definition>(const DB& db, const LIST& params, evaluation_product_definition* in)
+{
+    size_t base = GenericFill(db, params, static_cast<product_definition*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to evaluation_product_definition"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<event_occurrence>(const DB& db, const LIST& params, event_occurrence* in)
+{
+    size_t base = 0;
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to event_occurrence"); }    do { // convert the 'id' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::event_occurrence, 3>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->id, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to event_occurrence to be a `identifier`")); }
+    } while (0);
+    do { // convert the 'name' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::event_occurrence, 3>::aux_is_derived[1] = true; break; }
+        try { GenericConvert(in->name, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to event_occurrence to be a `label`")); }
+    } while (0);
+    do { // convert the 'description' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::event_occurrence, 3>::aux_is_derived[2] = true; break; }
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert(in->description, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to event_occurrence to be a `text`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<product_concept_feature_category>(const DB& db, const LIST& params, product_concept_feature_category* in)
+{
+    size_t base = GenericFill(db, params, static_cast<group*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to product_concept_feature_category"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<exclusive_product_concept_feature_category>(const DB& db, const LIST& params, exclusive_product_concept_feature_category* in)
+{
+    size_t base = GenericFill(db, params, static_cast<product_concept_feature_category*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to exclusive_product_concept_feature_category"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<uncertainty_qualifier>(const DB& db, const LIST& params, uncertainty_qualifier* in)
+{
+    size_t base = 0;
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to uncertainty_qualifier"); }    do { // convert the 'measure_name' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::uncertainty_qualifier, 2>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->measure_name, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to uncertainty_qualifier to be a `label`")); }
+    } while (0);
+    do { // convert the 'description' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::uncertainty_qualifier, 2>::aux_is_derived[1] = true; break; }
+        try { GenericConvert(in->description, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to uncertainty_qualifier to be a `text`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<standard_uncertainty>(const DB& db, const LIST& params, standard_uncertainty* in)
+{
+    size_t base = GenericFill(db, params, static_cast<uncertainty_qualifier*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to standard_uncertainty"); }    do { // convert the 'uncertainty_value' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::standard_uncertainty, 1>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->uncertainty_value, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to standard_uncertainty to be a `REAL`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<expanded_uncertainty>(const DB& db, const LIST& params, expanded_uncertainty* in)
+{
+    size_t base = GenericFill(db, params, static_cast<standard_uncertainty*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to expanded_uncertainty"); }    do { // convert the 'coverage_factor' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->coverage_factor, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to expanded_uncertainty to be a `REAL`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<representation_item_relationship>(const DB& db, const LIST& params, representation_item_relationship* in)
+{
+    size_t base = 0;
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to representation_item_relationship"); }    do { // convert the 'name' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::representation_item_relationship, 4>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->name, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to representation_item_relationship to be a `label`")); }
+    } while (0);
+    do { // convert the 'description' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::representation_item_relationship, 4>::aux_is_derived[1] = true; break; }
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert(in->description, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to representation_item_relationship to be a `text`")); }
+    } while (0);
+    do { // convert the 'relating_representation_item' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::representation_item_relationship, 4>::aux_is_derived[2] = true; break; }
+        try { GenericConvert(in->relating_representation_item, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to representation_item_relationship to be a `representation_item`")); }
+    } while (0);
+    do { // convert the 'related_representation_item' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::representation_item_relationship, 4>::aux_is_derived[3] = true; break; }
+        try { GenericConvert(in->related_representation_item, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to representation_item_relationship to be a `representation_item`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<explicit_procedural_representation_item_relationship>(const DB& db, const LIST& params, explicit_procedural_representation_item_relationship* in)
+{
+    size_t base = GenericFill(db, params, static_cast<representation_item_relationship*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to explicit_procedural_representation_item_relationship"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<explicit_procedural_geometric_representation_item_relationship>(const DB& db, const LIST& params, explicit_procedural_geometric_representation_item_relationship* in)
+{
+    size_t base = GenericFill(db, params, static_cast<explicit_procedural_representation_item_relationship*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to explicit_procedural_geometric_representation_item_relationship"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<explicit_procedural_representation_relationship>(const DB& db, const LIST& params, explicit_procedural_representation_relationship* in)
+{
+    size_t base = GenericFill(db, params, static_cast<representation_relationship*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to explicit_procedural_representation_relationship"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<explicit_procedural_shape_representation_relationship>(const DB& db, const LIST& params, explicit_procedural_shape_representation_relationship* in)
+{
+    size_t base = GenericFill(db, params, static_cast<explicit_procedural_representation_relationship*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to explicit_procedural_shape_representation_relationship"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<expression_conversion_based_unit>(const DB& db, const LIST& params, expression_conversion_based_unit* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<extension>(const DB& db, const LIST& params, extension* in)
+{
+    size_t base = GenericFill(db, params, static_cast<derived_shape_aspect*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to extension"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<extent>(const DB& db, const LIST& params, extent* in)
+{
+    size_t base = GenericFill(db, params, static_cast<characterized_object*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to extent"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<external_source>(const DB& db, const LIST& params, external_source* in)
+{
+    size_t base = 0;
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to external_source"); }    do { // convert the 'source_id' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::external_source, 1>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->source_id, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to external_source to be a `source_item`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<external_class_library>(const DB& db, const LIST& params, external_class_library* in)
+{
+    size_t base = GenericFill(db, params, static_cast<external_source*>(in));
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to external_class_library"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<externally_defined_class>(const DB& db, const LIST& params, externally_defined_class* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<externally_defined_colour>(const DB& db, const LIST& params, externally_defined_colour* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<externally_defined_context_dependent_unit>(const DB& db, const LIST& params, externally_defined_context_dependent_unit* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<externally_defined_conversion_based_unit>(const DB& db, const LIST& params, externally_defined_conversion_based_unit* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<externally_defined_currency>(const DB& db, const LIST& params, externally_defined_currency* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<externally_defined_item>(const DB& db, const LIST& params, externally_defined_item* in)
+{
+    size_t base = 0;
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to externally_defined_item"); }    do { // convert the 'item_id' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::externally_defined_item, 2>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->item_id, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to externally_defined_item to be a `source_item`")); }
+    } while (0);
+    do { // convert the 'source' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::externally_defined_item, 2>::aux_is_derived[1] = true; break; }
+        try { GenericConvert(in->source, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to externally_defined_item to be a `external_source`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<externally_defined_curve_font>(const DB& db, const LIST& params, externally_defined_curve_font* in)
+{
+    size_t base = GenericFill(db, params, static_cast<externally_defined_item*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to externally_defined_curve_font"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<externally_defined_dimension_definition>(const DB& db, const LIST& params, externally_defined_dimension_definition* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<externally_defined_general_property>(const DB& db, const LIST& params, externally_defined_general_property* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<externally_defined_hatch_style>(const DB& db, const LIST& params, externally_defined_hatch_style* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<externally_defined_marker>(const DB& db, const LIST& params, externally_defined_marker* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<picture_representation_item>(const DB& db, const LIST& params, picture_representation_item* in)
+{
+    size_t base = GenericFill(db, params, static_cast<bytes_representation_item*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to picture_representation_item"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<externally_defined_picture_representation_item>(const DB& db, const LIST& params, externally_defined_picture_representation_item* in)
+{
+    size_t base = GenericFill(db, params, static_cast<picture_representation_item*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to externally_defined_picture_representation_item"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<externally_defined_representation_item>(const DB& db, const LIST& params, externally_defined_representation_item* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<externally_defined_string>(const DB& db, const LIST& params, externally_defined_string* in)
+{
+    size_t base = GenericFill(db, params, static_cast<externally_defined_representation_item*>(in));
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<externally_defined_symbol>(const DB& db, const LIST& params, externally_defined_symbol* in)
+{
+    size_t base = GenericFill(db, params, static_cast<externally_defined_item*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to externally_defined_symbol"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<externally_defined_terminator_symbol>(const DB& db, const LIST& params, externally_defined_terminator_symbol* in)
+{
+    size_t base = GenericFill(db, params, static_cast<externally_defined_symbol*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to externally_defined_terminator_symbol"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<externally_defined_text_font>(const DB& db, const LIST& params, externally_defined_text_font* in)
+{
+    size_t base = GenericFill(db, params, static_cast<externally_defined_item*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to externally_defined_text_font"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<externally_defined_tile>(const DB& db, const LIST& params, externally_defined_tile* in)
+{
+    size_t base = GenericFill(db, params, static_cast<externally_defined_item*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to externally_defined_tile"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<externally_defined_tile_style>(const DB& db, const LIST& params, externally_defined_tile_style* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<swept_area_solid>(const DB& db, const LIST& params, swept_area_solid* in)
+{
+    size_t base = GenericFill(db, params, static_cast<solid_model*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to swept_area_solid"); }    do { // convert the 'swept_area' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::swept_area_solid, 1>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->swept_area, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to swept_area_solid to be a `curve_bounded_surface`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<extruded_area_solid>(const DB& db, const LIST& params, extruded_area_solid* in)
+{
+    size_t base = GenericFill(db, params, static_cast<swept_area_solid*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to extruded_area_solid"); }    do { // convert the 'extruded_direction' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->extruded_direction, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to extruded_area_solid to be a `direction`")); }
+    } while (0);
+    do { // convert the 'depth' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->depth, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to extruded_area_solid to be a `positive_length_measure`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<swept_face_solid>(const DB& db, const LIST& params, swept_face_solid* in)
+{
+    size_t base = GenericFill(db, params, static_cast<solid_model*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to swept_face_solid"); }    do { // convert the 'swept_face' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::swept_face_solid, 1>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->swept_face, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to swept_face_solid to be a `face_surface`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<extruded_face_solid>(const DB& db, const LIST& params, extruded_face_solid* in)
+{
+    size_t base = GenericFill(db, params, static_cast<swept_face_solid*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to extruded_face_solid"); }    do { // convert the 'extruded_direction' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::extruded_face_solid, 2>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->extruded_direction, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to extruded_face_solid to be a `direction`")); }
+    } while (0);
+    do { // convert the 'depth' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::extruded_face_solid, 2>::aux_is_derived[1] = true; break; }
+        try { GenericConvert(in->depth, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to extruded_face_solid to be a `positive_length_measure`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<extruded_face_solid_with_trim_conditions>(const DB& db, const LIST& params, extruded_face_solid_with_trim_conditions* in)
+{
+    size_t base = GenericFill(db, params, static_cast<extruded_face_solid*>(in));
+    if (params.GetSize() < 10) { throw STEP::TypeError("expected 10 arguments to extruded_face_solid_with_trim_conditions"); }    do { // convert the 'first_trim_condition' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::extruded_face_solid_with_trim_conditions, 6>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->first_trim_condition, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to extruded_face_solid_with_trim_conditions to be a `trim_condition_select`")); }
+    } while (0);
+    do { // convert the 'second_trim_condition' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::extruded_face_solid_with_trim_conditions, 6>::aux_is_derived[1] = true; break; }
+        try { GenericConvert(in->second_trim_condition, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to extruded_face_solid_with_trim_conditions to be a `trim_condition_select`")); }
+    } while (0);
+    do { // convert the 'first_trim_intent' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::extruded_face_solid_with_trim_conditions, 6>::aux_is_derived[2] = true; break; }
+        try { GenericConvert(in->first_trim_intent, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to extruded_face_solid_with_trim_conditions to be a `trim_intent`")); }
+    } while (0);
+    do { // convert the 'second_trim_intent' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::extruded_face_solid_with_trim_conditions, 6>::aux_is_derived[3] = true; break; }
+        try { GenericConvert(in->second_trim_intent, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to extruded_face_solid_with_trim_conditions to be a `trim_intent`")); }
+    } while (0);
+    do { // convert the 'first_offset' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::extruded_face_solid_with_trim_conditions, 6>::aux_is_derived[4] = true; break; }
+        try { GenericConvert(in->first_offset, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 8 to extruded_face_solid_with_trim_conditions to be a `non_negative_length_measure`")); }
+    } while (0);
+    do { // convert the 'second_offset' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::extruded_face_solid_with_trim_conditions, 6>::aux_is_derived[5] = true; break; }
+        try { GenericConvert(in->second_offset, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 9 to extruded_face_solid_with_trim_conditions to be a `non_negative_length_measure`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<extruded_face_solid_with_draft_angle>(const DB& db, const LIST& params, extruded_face_solid_with_draft_angle* in)
+{
+    size_t base = GenericFill(db, params, static_cast<extruded_face_solid_with_trim_conditions*>(in));
+    if (params.GetSize() < 11) { throw STEP::TypeError("expected 11 arguments to extruded_face_solid_with_draft_angle"); }    do { // convert the 'draft_angle' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->draft_angle, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 10 to extruded_face_solid_with_draft_angle to be a `plane_angle_measure`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<extruded_face_solid_with_multiple_draft_angles>(const DB& db, const LIST& params, extruded_face_solid_with_multiple_draft_angles* in)
+{
+    size_t base = GenericFill(db, params, static_cast<extruded_face_solid_with_trim_conditions*>(in));
+    if (params.GetSize() < 11) { throw STEP::TypeError("expected 11 arguments to extruded_face_solid_with_multiple_draft_angles"); }    do { // convert the 'draft_angles' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->draft_angles, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 10 to extruded_face_solid_with_multiple_draft_angles to be a `LIST [2:?] OF plane_angle_measure`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<face>(const DB& db, const LIST& params, face* in)
+{
+    size_t base = GenericFill(db, params, static_cast<topological_representation_item*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to face"); }    do { // convert the 'bounds' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::face, 1>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->bounds, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to face to be a `SET [1:?] OF face_bound`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<face_based_surface_model>(const DB& db, const LIST& params, face_based_surface_model* in)
+{
+    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to face_based_surface_model"); }    do { // convert the 'fbsm_faces' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->fbsm_faces, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to face_based_surface_model to be a `SET [1:?] OF connected_face_set`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<face_bound>(const DB& db, const LIST& params, face_bound* in)
+{
+    size_t base = GenericFill(db, params, static_cast<topological_representation_item*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to face_bound"); }    do { // convert the 'bound' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::face_bound, 2>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->bound, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to face_bound to be a `loop`")); }
+    } while (0);
+    do { // convert the 'orientation' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::face_bound, 2>::aux_is_derived[1] = true; break; }
+        try { GenericConvert(in->orientation, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to face_bound to be a `BOOLEAN`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<face_outer_bound>(const DB& db, const LIST& params, face_outer_bound* in)
+{
+    size_t base = GenericFill(db, params, static_cast<face_bound*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to face_outer_bound"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<faceted_brep>(const DB& db, const LIST& params, faceted_brep* in)
+{
+    size_t base = GenericFill(db, params, static_cast<manifold_solid_brep*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to faceted_brep"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<faceted_brep_shape_representation>(const DB& db, const LIST& params, faceted_brep_shape_representation* in)
+{
+    size_t base = GenericFill(db, params, static_cast<shape_representation*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to faceted_brep_shape_representation"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<fill_area_style>(const DB& db, const LIST& params, fill_area_style* in)
+{
+    size_t base = GenericFill(db, params, static_cast<founded_item*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to fill_area_style"); }    do { // convert the 'name' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->name, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to fill_area_style to be a `label`")); }
+    } while (0);
+    do { // convert the 'fill_styles' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->fill_styles, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to fill_area_style to be a `SET [1:?] OF fill_style_select`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<fill_area_style_hatching>(const DB& db, const LIST& params, fill_area_style_hatching* in)
+{
+    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
+    if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to fill_area_style_hatching"); }    do { // convert the 'hatch_line_appearance' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->hatch_line_appearance, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to fill_area_style_hatching to be a `curve_style`")); }
+    } while (0);
+    do { // convert the 'start_of_next_hatch_line' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->start_of_next_hatch_line, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to fill_area_style_hatching to be a `one_direction_repeat_factor`")); }
+    } while (0);
+    do { // convert the 'point_of_reference_hatch_line' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->point_of_reference_hatch_line, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to fill_area_style_hatching to be a `cartesian_point`")); }
+    } while (0);
+    do { // convert the 'pattern_start' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->pattern_start, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to fill_area_style_hatching to be a `cartesian_point`")); }
+    } while (0);
+    do { // convert the 'hatch_line_angle' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->hatch_line_angle, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to fill_area_style_hatching to be a `plane_angle_measure`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<fill_area_style_tile_coloured_region>(const DB& db, const LIST& params, fill_area_style_tile_coloured_region* in)
+{
+    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to fill_area_style_tile_coloured_region"); }    do { // convert the 'closed_curve' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->closed_curve, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to fill_area_style_tile_coloured_region to be a `curve_or_annotation_curve_occurrence`")); }
+    } while (0);
+    do { // convert the 'region_colour' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->region_colour, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to fill_area_style_tile_coloured_region to be a `colour`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<fill_area_style_tile_curve_with_style>(const DB& db, const LIST& params, fill_area_style_tile_curve_with_style* in)
+{
+    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to fill_area_style_tile_curve_with_style"); }    do { // convert the 'styled_curve' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->styled_curve, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to fill_area_style_tile_curve_with_style to be a `annotation_curve_occurrence`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<fill_area_style_tile_symbol_with_style>(const DB& db, const LIST& params, fill_area_style_tile_symbol_with_style* in)
+{
+    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to fill_area_style_tile_symbol_with_style"); }    do { // convert the 'symbol' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->symbol, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to fill_area_style_tile_symbol_with_style to be a `annotation_symbol_occurrence`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<fill_area_style_tiles>(const DB& db, const LIST& params, fill_area_style_tiles* in)
+{
+    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to fill_area_style_tiles"); }    do { // convert the 'tiling_pattern' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->tiling_pattern, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to fill_area_style_tiles to be a `two_direction_repeat_factor`")); }
+    } while (0);
+    do { // convert the 'tiles' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->tiles, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to fill_area_style_tiles to be a `SET [1:?] OF fill_area_style_tile_shape_select`")); }
+    } while (0);
+    do { // convert the 'tiling_scale' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->tiling_scale, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to fill_area_style_tiles to be a `positive_ratio_measure`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<shape_representation_relationship>(const DB& db, const LIST& params, shape_representation_relationship* in)
+{
+    size_t base = GenericFill(db, params, static_cast<representation_relationship*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to shape_representation_relationship"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<flat_pattern_ply_representation_relationship>(const DB& db, const LIST& params, flat_pattern_ply_representation_relationship* in)
+{
+    size_t base = GenericFill(db, params, static_cast<shape_representation_relationship*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to flat_pattern_ply_representation_relationship"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<flatness_tolerance>(const DB& db, const LIST& params, flatness_tolerance* in)
+{
+    size_t base = GenericFill(db, params, static_cast<geometric_tolerance*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to flatness_tolerance"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<force_measure_with_unit>(const DB& db, const LIST& params, force_measure_with_unit* in)
+{
+    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to force_measure_with_unit"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<force_unit>(const DB& db, const LIST& params, force_unit* in)
+{
+    size_t base = GenericFill(db, params, static_cast<derived_unit*>(in));
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to force_unit"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<forward_chaining_rule>(const DB& db, const LIST& params, forward_chaining_rule* in)
+{
+    size_t base = GenericFill(db, params, static_cast<rule_definition*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to forward_chaining_rule"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<forward_chaining_rule_premise>(const DB& db, const LIST& params, forward_chaining_rule_premise* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<frequency_measure_with_unit>(const DB& db, const LIST& params, frequency_measure_with_unit* in)
+{
+    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to frequency_measure_with_unit"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<frequency_unit>(const DB& db, const LIST& params, frequency_unit* in)
+{
+    size_t base = GenericFill(db, params, static_cast<derived_unit*>(in));
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to frequency_unit"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<func>(const DB& db, const LIST& params, func* in)
+{
+    size_t base = GenericFill(db, params, static_cast<compound_representation_item*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to func"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<functional_breakdown_context>(const DB& db, const LIST& params, functional_breakdown_context* in)
+{
+    size_t base = GenericFill(db, params, static_cast<breakdown_context*>(in));
+    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to functional_breakdown_context"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<functional_element_usage>(const DB& db, const LIST& params, functional_element_usage* in)
+{
+    size_t base = GenericFill(db, params, static_cast<breakdown_element_usage*>(in));
+    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to functional_element_usage"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<general_material_property>(const DB& db, const LIST& params, general_material_property* in)
+{
+    size_t base = GenericFill(db, params, static_cast<general_property*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to general_material_property"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<simple_generic_expression>(const DB& db, const LIST& params, simple_generic_expression* in)
+{
+    size_t base = GenericFill(db, params, static_cast<generic_expression*>(in));
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<generic_literal>(const DB& db, const LIST& params, generic_literal* in)
+{
+    size_t base = GenericFill(db, params, static_cast<simple_generic_expression*>(in));
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<generic_variable>(const DB& db, const LIST& params, generic_variable* in)
+{
+    size_t base = GenericFill(db, params, static_cast<simple_generic_expression*>(in));
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<geometric_alignment>(const DB& db, const LIST& params, geometric_alignment* in)
+{
+    size_t base = GenericFill(db, params, static_cast<derived_shape_aspect*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to geometric_alignment"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<geometric_set>(const DB& db, const LIST& params, geometric_set* in)
+{
+    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to geometric_set"); }    do { // convert the 'elements' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::geometric_set, 1>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->elements, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to geometric_set to be a `SET [1:?] OF geometric_set_select`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<geometric_curve_set>(const DB& db, const LIST& params, geometric_curve_set* in)
+{
+    size_t base = GenericFill(db, params, static_cast<geometric_set*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to geometric_curve_set"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<geometric_intersection>(const DB& db, const LIST& params, geometric_intersection* in)
+{
+    size_t base = GenericFill(db, params, static_cast<derived_shape_aspect*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to geometric_intersection"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<geometric_item_specific_usage>(const DB& db, const LIST& params, geometric_item_specific_usage* in)
+{
+    size_t base = GenericFill(db, params, static_cast<item_identified_representation_usage*>(in));
+    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to geometric_item_specific_usage"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<geometric_model_element_relationship>(const DB& db, const LIST& params, geometric_model_element_relationship* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<representation_context>(const DB& db, const LIST& params, representation_context* in)
+{
+    size_t base = 0;
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to representation_context"); }    do { // convert the 'context_identifier' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::representation_context, 2>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->context_identifier, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to representation_context to be a `identifier`")); }
+    } while (0);
+    do { // convert the 'context_type' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::representation_context, 2>::aux_is_derived[1] = true; break; }
+        try { GenericConvert(in->context_type, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to representation_context to be a `text`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<geometric_representation_context>(const DB& db, const LIST& params, geometric_representation_context* in)
+{
+    size_t base = GenericFill(db, params, static_cast<representation_context*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to geometric_representation_context"); }    do { // convert the 'coordinate_space_dimension' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->coordinate_space_dimension, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to geometric_representation_context to be a `dimension_count`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<geometric_tolerance_with_defined_unit>(const DB& db, const LIST& params, geometric_tolerance_with_defined_unit* in)
+{
+    size_t base = GenericFill(db, params, static_cast<geometric_tolerance*>(in));
+    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to geometric_tolerance_with_defined_unit"); }    do { // convert the 'unit_size' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->unit_size, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to geometric_tolerance_with_defined_unit to be a `measure_with_unit`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<geometrical_tolerance_callout>(const DB& db, const LIST& params, geometrical_tolerance_callout* in)
+{
+    size_t base = GenericFill(db, params, static_cast<draughting_callout*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to geometrical_tolerance_callout"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<geometrically_bounded_2d_wireframe_representation>(const DB& db, const LIST& params, geometrically_bounded_2d_wireframe_representation* in)
+{
+    size_t base = GenericFill(db, params, static_cast<shape_representation*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to geometrically_bounded_2d_wireframe_representation"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<geometrically_bounded_surface_shape_representation>(const DB& db, const LIST& params, geometrically_bounded_surface_shape_representation* in)
+{
+    size_t base = GenericFill(db, params, static_cast<shape_representation*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to geometrically_bounded_surface_shape_representation"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<geometrically_bounded_wireframe_shape_representation>(const DB& db, const LIST& params, geometrically_bounded_wireframe_shape_representation* in)
+{
+    size_t base = GenericFill(db, params, static_cast<shape_representation*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to geometrically_bounded_wireframe_shape_representation"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<global_assignment>(const DB& db, const LIST& params, global_assignment* in)
+{
+    size_t base = GenericFill(db, params, static_cast<representation_item_relationship*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to global_assignment"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<global_uncertainty_assigned_context>(const DB& db, const LIST& params, global_uncertainty_assigned_context* in)
+{
+    size_t base = GenericFill(db, params, static_cast<representation_context*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to global_uncertainty_assigned_context"); }    do { // convert the 'uncertainty' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->uncertainty, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to global_uncertainty_assigned_context to be a `SET [1:?] OF uncertainty_measure_with_unit`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<global_unit_assigned_context>(const DB& db, const LIST& params, global_unit_assigned_context* in)
+{
+    size_t base = GenericFill(db, params, static_cast<representation_context*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to global_unit_assigned_context"); }    do { // convert the 'units' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->units, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to global_unit_assigned_context to be a `SET [1:?] OF unit`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<ground_fact>(const DB& db, const LIST& params, ground_fact* in)
+{
+    size_t base = GenericFill(db, params, static_cast<atomic_formula*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to ground_fact"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<hardness_representation>(const DB& db, const LIST& params, hardness_representation* in)
+{
+    size_t base = GenericFill(db, params, static_cast<representation*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to hardness_representation"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<hidden_element_over_riding_styled_item>(const DB& db, const LIST& params, hidden_element_over_riding_styled_item* in)
+{
+    size_t base = GenericFill(db, params, static_cast<context_dependent_over_riding_styled_item*>(in));
+    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to hidden_element_over_riding_styled_item"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<hyperbola>(const DB& db, const LIST& params, hyperbola* in)
+{
+    size_t base = GenericFill(db, params, static_cast<conic*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to hyperbola"); }    do { // convert the 'semi_axis' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->semi_axis, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to hyperbola to be a `positive_length_measure`")); }
+    } while (0);
+    do { // convert the 'semi_imag_axis' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->semi_imag_axis, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to hyperbola to be a `positive_length_measure`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<illuminance_measure_with_unit>(const DB& db, const LIST& params, illuminance_measure_with_unit* in)
+{
+    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to illuminance_measure_with_unit"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<illuminance_unit>(const DB& db, const LIST& params, illuminance_unit* in)
+{
+    size_t base = GenericFill(db, params, static_cast<derived_unit*>(in));
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to illuminance_unit"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<included_text_block>(const DB& db, const LIST& params, included_text_block* in)
+{
+    size_t base = GenericFill(db, params, static_cast<mapped_item*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to included_text_block"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<inclusion_product_concept_feature>(const DB& db, const LIST& params, inclusion_product_concept_feature* in)
+{
+    size_t base = GenericFill(db, params, static_cast<conditional_concept_feature*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to inclusion_product_concept_feature"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<user_selected_elements>(const DB& db, const LIST& params, user_selected_elements* in)
+{
+    size_t base = GenericFill(db, params, static_cast<representation_item*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to user_selected_elements"); }    do { // convert the 'picked_items' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::user_selected_elements, 1>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->picked_items, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to user_selected_elements to be a `SET [1:?] OF representation_item`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<indirectly_selected_elements>(const DB& db, const LIST& params, indirectly_selected_elements* in)
+{
+    size_t base = GenericFill(db, params, static_cast<user_selected_elements*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to indirectly_selected_elements"); }    do { // convert the 'indirectly_picked_items' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->indirectly_picked_items, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to indirectly_selected_elements to be a `SET [1:?] OF representation_item`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<indirectly_selected_shape_elements>(const DB& db, const LIST& params, indirectly_selected_shape_elements* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<inductance_measure_with_unit>(const DB& db, const LIST& params, inductance_measure_with_unit* in)
+{
+    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to inductance_measure_with_unit"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<inductance_unit>(const DB& db, const LIST& params, inductance_unit* in)
+{
+    size_t base = GenericFill(db, params, static_cast<derived_unit*>(in));
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to inductance_unit"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<information_right>(const DB& db, const LIST& params, information_right* in)
+{
+    size_t base = GenericFill(db, params, static_cast<action_method*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to information_right"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<information_usage_right>(const DB& db, const LIST& params, information_usage_right* in)
+{
+    size_t base = GenericFill(db, params, static_cast<action_method*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to information_usage_right"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<instance_usage_context_assignment>(const DB& db, const LIST& params, instance_usage_context_assignment* in)
+{
+    size_t base = GenericFill(db, params, static_cast<product_definition_context*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to instance_usage_context_assignment"); }    do { // convert the 'items' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->items, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to instance_usage_context_assignment to be a `SET [1:?] OF instance_usage_context_select`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<instanced_feature>(const DB& db, const LIST& params, instanced_feature* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<literal_number>(const DB& db, const LIST& params, literal_number* in)
+{
+    size_t base = 0;
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to literal_number"); }    do { // convert the 'the_value' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::literal_number, 1>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->the_value, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to literal_number to be a `NUMBER`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<int_literal>(const DB& db, const LIST& params, int_literal* in)
+{
+    size_t base = GenericFill(db, params, static_cast<literal_number*>(in));
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to int_literal"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<integer_representation_item>(const DB& db, const LIST& params, integer_representation_item* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<surface_curve>(const DB& db, const LIST& params, surface_curve* in)
+{
+    size_t base = GenericFill(db, params, static_cast<curve*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to surface_curve"); }    do { // convert the 'curve_3d' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::surface_curve, 3>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->curve_3d, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to surface_curve to be a `curve`")); }
+    } while (0);
+    do { // convert the 'associated_geometry' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::surface_curve, 3>::aux_is_derived[1] = true; break; }
+        try { GenericConvert(in->associated_geometry, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to surface_curve to be a `LIST [1:2] OF pcurve_or_surface`")); }
+    } while (0);
+    do { // convert the 'master_representation' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::surface_curve, 3>::aux_is_derived[2] = true; break; }
+        try { GenericConvert(in->master_representation, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to surface_curve to be a `preferred_surface_curve_representation`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<intersection_curve>(const DB& db, const LIST& params, intersection_curve* in)
+{
+    size_t base = GenericFill(db, params, static_cast<surface_curve*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to intersection_curve"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<interval_expression>(const DB& db, const LIST& params, interval_expression* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<iso4217_currency>(const DB& db, const LIST& params, iso4217_currency* in)
+{
+    size_t base = GenericFill(db, params, static_cast<currency*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to iso4217_currency"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<known_source>(const DB& db, const LIST& params, known_source* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<laid_defined_transformation>(const DB& db, const LIST& params, laid_defined_transformation* in)
+{
+    size_t base = GenericFill(db, params, static_cast<transformation_with_derived_angle*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to laid_defined_transformation"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<language>(const DB& db, const LIST& params, language* in)
+{
+    size_t base = GenericFill(db, params, static_cast<group*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to language"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<leader_curve>(const DB& db, const LIST& params, leader_curve* in)
+{
+    size_t base = GenericFill(db, params, static_cast<annotation_curve_occurrence*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to leader_curve"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<leader_directed_callout>(const DB& db, const LIST& params, leader_directed_callout* in)
+{
+    size_t base = GenericFill(db, params, static_cast<draughting_callout*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to leader_directed_callout"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<leader_directed_dimension>(const DB& db, const LIST& params, leader_directed_dimension* in)
+{
+    size_t base = GenericFill(db, params, static_cast<leader_directed_callout*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to leader_directed_dimension"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<leader_terminator>(const DB& db, const LIST& params, leader_terminator* in)
+{
+    size_t base = GenericFill(db, params, static_cast<terminator_symbol*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to leader_terminator"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<length_measure_with_unit>(const DB& db, const LIST& params, length_measure_with_unit* in)
+{
+    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to length_measure_with_unit"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<length_unit>(const DB& db, const LIST& params, length_unit* in)
+{
+    size_t base = GenericFill(db, params, static_cast<named_unit*>(in));
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to length_unit"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<light_source>(const DB& db, const LIST& params, light_source* in)
+{
+    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to light_source"); }    do { // convert the 'light_colour' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::light_source, 1>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->light_colour, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to light_source to be a `colour`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<light_source_ambient>(const DB& db, const LIST& params, light_source_ambient* in)
+{
+    size_t base = GenericFill(db, params, static_cast<light_source*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to light_source_ambient"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<light_source_directional>(const DB& db, const LIST& params, light_source_directional* in)
+{
+    size_t base = GenericFill(db, params, static_cast<light_source*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to light_source_directional"); }    do { // convert the 'orientation' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->orientation, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to light_source_directional to be a `direction`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<light_source_positional>(const DB& db, const LIST& params, light_source_positional* in)
+{
+    size_t base = GenericFill(db, params, static_cast<light_source*>(in));
+    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to light_source_positional"); }    do { // convert the 'position' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->position, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to light_source_positional to be a `cartesian_point`")); }
+    } while (0);
+    do { // convert the 'constant_attenuation' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->constant_attenuation, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to light_source_positional to be a `REAL`")); }
+    } while (0);
+    do { // convert the 'distance_attenuation' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->distance_attenuation, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to light_source_positional to be a `REAL`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<light_source_spot>(const DB& db, const LIST& params, light_source_spot* in)
+{
+    size_t base = GenericFill(db, params, static_cast<light_source*>(in));
+    if (params.GetSize() < 8) { throw STEP::TypeError("expected 8 arguments to light_source_spot"); }    do { // convert the 'position' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->position, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to light_source_spot to be a `cartesian_point`")); }
+    } while (0);
+    do { // convert the 'orientation' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->orientation, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to light_source_spot to be a `direction`")); }
+    } while (0);
+    do { // convert the 'concentration_exponent' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->concentration_exponent, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to light_source_spot to be a `REAL`")); }
+    } while (0);
+    do { // convert the 'constant_attenuation' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->constant_attenuation, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to light_source_spot to be a `REAL`")); }
+    } while (0);
+    do { // convert the 'distance_attenuation' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->distance_attenuation, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to light_source_spot to be a `REAL`")); }
+    } while (0);
+    do { // convert the 'spread_angle' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->spread_angle, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to light_source_spot to be a `positive_plane_angle_measure`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<line>(const DB& db, const LIST& params, line* in)
+{
+    size_t base = GenericFill(db, params, static_cast<curve*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to line"); }    do { // convert the 'pnt' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->pnt, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to line to be a `cartesian_point`")); }
+    } while (0);
+    do { // convert the 'dir' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->dir, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to line to be a `vector`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<line_profile_tolerance>(const DB& db, const LIST& params, line_profile_tolerance* in)
+{
+    size_t base = GenericFill(db, params, static_cast<geometric_tolerance*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to line_profile_tolerance"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<linear_dimension>(const DB& db, const LIST& params, linear_dimension* in)
+{
+    size_t base = GenericFill(db, params, static_cast<dimension_curve_directed_callout*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to linear_dimension"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<simple_clause>(const DB& db, const LIST& params, simple_clause* in)
+{
+    size_t base = GenericFill(db, params, static_cast<compound_representation_item*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to simple_clause"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<literal_conjunction>(const DB& db, const LIST& params, literal_conjunction* in)
+{
+    size_t base = GenericFill(db, params, static_cast<simple_clause*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to literal_conjunction"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<literal_disjunction>(const DB& db, const LIST& params, literal_disjunction* in)
+{
+    size_t base = GenericFill(db, params, static_cast<simple_clause*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to literal_disjunction"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<logical_literal>(const DB& db, const LIST& params, logical_literal* in)
+{
+    size_t base = GenericFill(db, params, static_cast<generic_literal*>(in));
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to logical_literal"); }    do { // convert the 'lit_value' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->lit_value, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to logical_literal to be a `LOGICAL`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<logical_representation_item>(const DB& db, const LIST& params, logical_representation_item* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<loop>(const DB& db, const LIST& params, loop* in)
+{
+    size_t base = GenericFill(db, params, static_cast<topological_representation_item*>(in));
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to loop"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<loss_tangent_measure_with_unit>(const DB& db, const LIST& params, loss_tangent_measure_with_unit* in)
+{
+    size_t base = GenericFill(db, params, static_cast<ratio_measure_with_unit*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to loss_tangent_measure_with_unit"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<lot_effectivity>(const DB& db, const LIST& params, lot_effectivity* in)
+{
+    size_t base = GenericFill(db, params, static_cast<effectivity*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to lot_effectivity"); }    do { // convert the 'effectivity_lot_id' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->effectivity_lot_id, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to lot_effectivity to be a `identifier`")); }
+    } while (0);
+    do { // convert the 'effectivity_lot_size' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->effectivity_lot_size, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to lot_effectivity to be a `measure_with_unit`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<luminous_flux_measure_with_unit>(const DB& db, const LIST& params, luminous_flux_measure_with_unit* in)
+{
+    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to luminous_flux_measure_with_unit"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<luminous_flux_unit>(const DB& db, const LIST& params, luminous_flux_unit* in)
+{
+    size_t base = GenericFill(db, params, static_cast<named_unit*>(in));
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to luminous_flux_unit"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<luminous_intensity_measure_with_unit>(const DB& db, const LIST& params, luminous_intensity_measure_with_unit* in)
+{
+    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to luminous_intensity_measure_with_unit"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<luminous_intensity_unit>(const DB& db, const LIST& params, luminous_intensity_unit* in)
+{
+    size_t base = GenericFill(db, params, static_cast<named_unit*>(in));
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to luminous_intensity_unit"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<magnetic_flux_density_measure_with_unit>(const DB& db, const LIST& params, magnetic_flux_density_measure_with_unit* in)
+{
+    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to magnetic_flux_density_measure_with_unit"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<magnetic_flux_density_unit>(const DB& db, const LIST& params, magnetic_flux_density_unit* in)
+{
+    size_t base = GenericFill(db, params, static_cast<derived_unit*>(in));
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to magnetic_flux_density_unit"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<magnetic_flux_measure_with_unit>(const DB& db, const LIST& params, magnetic_flux_measure_with_unit* in)
+{
+    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to magnetic_flux_measure_with_unit"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<magnetic_flux_unit>(const DB& db, const LIST& params, magnetic_flux_unit* in)
+{
+    size_t base = GenericFill(db, params, static_cast<derived_unit*>(in));
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to magnetic_flux_unit"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<make_from_usage_option>(const DB& db, const LIST& params, make_from_usage_option* in)
+{
+    size_t base = GenericFill(db, params, static_cast<product_definition_usage*>(in));
+    if (params.GetSize() < 8) { throw STEP::TypeError("expected 8 arguments to make_from_usage_option"); }    do { // convert the 'ranking' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->ranking, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to make_from_usage_option to be a `INTEGER`")); }
+    } while (0);
+    do { // convert the 'ranking_rationale' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->ranking_rationale, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to make_from_usage_option to be a `text`")); }
+    } while (0);
+    do { // convert the 'quantity' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->quantity, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to make_from_usage_option to be a `measure_with_unit`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<manifold_subsurface_shape_representation>(const DB& db, const LIST& params, manifold_subsurface_shape_representation* in)
+{
+    size_t base = GenericFill(db, params, static_cast<shape_representation*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to manifold_subsurface_shape_representation"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<manifold_surface_shape_representation>(const DB& db, const LIST& params, manifold_surface_shape_representation* in)
+{
+    size_t base = GenericFill(db, params, static_cast<shape_representation*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to manifold_surface_shape_representation"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<mass_measure_with_unit>(const DB& db, const LIST& params, mass_measure_with_unit* in)
+{
+    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to mass_measure_with_unit"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<mass_unit>(const DB& db, const LIST& params, mass_unit* in)
+{
+    size_t base = GenericFill(db, params, static_cast<named_unit*>(in));
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to mass_unit"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<material_property>(const DB& db, const LIST& params, material_property* in)
+{
+    size_t base = GenericFill(db, params, static_cast<property_definition*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to material_property"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<property_definition_representation>(const DB& db, const LIST& params, property_definition_representation* in)
+{
+    size_t base = 0;
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to property_definition_representation"); }    do { // convert the 'definition' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::property_definition_representation, 2>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->definition, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to property_definition_representation to be a `represented_definition`")); }
+    } while (0);
+    do { // convert the 'used_representation' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::property_definition_representation, 2>::aux_is_derived[1] = true; break; }
+        try { GenericConvert(in->used_representation, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to property_definition_representation to be a `representation`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<material_property_representation>(const DB& db, const LIST& params, material_property_representation* in)
+{
+    size_t base = GenericFill(db, params, static_cast<property_definition_representation*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to material_property_representation"); }    do { // convert the 'dependent_environment' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->dependent_environment, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to material_property_representation to be a `data_environment`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<measure_representation_item>(const DB& db, const LIST& params, measure_representation_item* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<product_context>(const DB& db, const LIST& params, product_context* in)
+{
+    size_t base = GenericFill(db, params, static_cast<application_context_element*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to product_context"); }    do { // convert the 'discipline_type' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::product_context, 1>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->discipline_type, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to product_context to be a `label`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<mechanical_context>(const DB& db, const LIST& params, mechanical_context* in)
+{
+    size_t base = GenericFill(db, params, static_cast<product_context*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to mechanical_context"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<mechanical_design_and_draughting_relationship>(const DB& db, const LIST& params, mechanical_design_and_draughting_relationship* in)
+{
+    size_t base = GenericFill(db, params, static_cast<definitional_representation_relationship_with_same_context*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to mechanical_design_and_draughting_relationship"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<mechanical_design_geometric_presentation_area>(const DB& db, const LIST& params, mechanical_design_geometric_presentation_area* in)
+{
+    size_t base = GenericFill(db, params, static_cast<presentation_area*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to mechanical_design_geometric_presentation_area"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<mechanical_design_geometric_presentation_representation>(const DB& db, const LIST& params, mechanical_design_geometric_presentation_representation* in)
+{
+    size_t base = GenericFill(db, params, static_cast<representation*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to mechanical_design_geometric_presentation_representation"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<mechanical_design_presentation_representation_with_draughting>(const DB& db, const LIST& params, mechanical_design_presentation_representation_with_draughting* in)
+{
+    size_t base = GenericFill(db, params, static_cast<representation*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to mechanical_design_presentation_representation_with_draughting"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<mechanical_design_shaded_presentation_area>(const DB& db, const LIST& params, mechanical_design_shaded_presentation_area* in)
+{
+    size_t base = GenericFill(db, params, static_cast<presentation_area*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to mechanical_design_shaded_presentation_area"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<mechanical_design_shaded_presentation_representation>(const DB& db, const LIST& params, mechanical_design_shaded_presentation_representation* in)
+{
+    size_t base = GenericFill(db, params, static_cast<representation*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to mechanical_design_shaded_presentation_representation"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<min_and_major_ply_orientation_basis>(const DB& db, const LIST& params, min_and_major_ply_orientation_basis* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<modified_geometric_tolerance>(const DB& db, const LIST& params, modified_geometric_tolerance* in)
+{
+    size_t base = GenericFill(db, params, static_cast<geometric_tolerance*>(in));
+    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to modified_geometric_tolerance"); }    do { // convert the 'modifier' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->modifier, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to modified_geometric_tolerance to be a `limit_condition`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<modified_solid_with_placed_configuration>(const DB& db, const LIST& params, modified_solid_with_placed_configuration* in)
+{
+    size_t base = GenericFill(db, params, static_cast<modified_solid*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to modified_solid_with_placed_configuration"); }    do { // convert the 'placing' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::modified_solid_with_placed_configuration, 1>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->placing, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to modified_solid_with_placed_configuration to be a `axis2_placement_3d`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<moments_of_inertia_representation>(const DB& db, const LIST& params, moments_of_inertia_representation* in)
+{
+    size_t base = GenericFill(db, params, static_cast<representation*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to moments_of_inertia_representation"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<multi_language_attribute_assignment>(const DB& db, const LIST& params, multi_language_attribute_assignment* in)
+{
+    size_t base = GenericFill(db, params, static_cast<attribute_value_assignment*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to multi_language_attribute_assignment"); }    do { // convert the 'items' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->items, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to multi_language_attribute_assignment to be a `SET [1:?] OF multi_language_attribute_item`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<multiple_arity_boolean_expression>(const DB& db, const LIST& params, multiple_arity_boolean_expression* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<multiple_arity_generic_expression>(const DB& db, const LIST& params, multiple_arity_generic_expression* in)
+{
+    size_t base = GenericFill(db, params, static_cast<generic_expression*>(in));
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to multiple_arity_generic_expression"); }    do { // convert the 'operands' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->operands, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to multiple_arity_generic_expression to be a `LIST [2:?] OF generic_expression`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<multiple_arity_numeric_expression>(const DB& db, const LIST& params, multiple_arity_numeric_expression* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<next_assembly_usage_occurrence>(const DB& db, const LIST& params, next_assembly_usage_occurrence* in)
+{
+    size_t base = GenericFill(db, params, static_cast<assembly_component_usage*>(in));
+    if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to next_assembly_usage_occurrence"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<non_manifold_surface_shape_representation>(const DB& db, const LIST& params, non_manifold_surface_shape_representation* in)
+{
+    size_t base = GenericFill(db, params, static_cast<shape_representation*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to non_manifold_surface_shape_representation"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<null_representation_item>(const DB& db, const LIST& params, null_representation_item* in)
+{
+    size_t base = GenericFill(db, params, static_cast<representation_item*>(in));
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to null_representation_item"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<numeric_expression>(const DB& db, const LIST& params, numeric_expression* in)
+{
+    size_t base = GenericFill(db, params, static_cast<expression*>(in));
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<offset_curve_2d>(const DB& db, const LIST& params, offset_curve_2d* in)
+{
+    size_t base = GenericFill(db, params, static_cast<curve*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to offset_curve_2d"); }    do { // convert the 'basis_curve' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->basis_curve, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to offset_curve_2d to be a `curve`")); }
+    } while (0);
+    do { // convert the 'distance' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->distance, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to offset_curve_2d to be a `length_measure`")); }
+    } while (0);
+    do { // convert the 'self_intersect' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->self_intersect, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to offset_curve_2d to be a `LOGICAL`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<offset_curve_3d>(const DB& db, const LIST& params, offset_curve_3d* in)
+{
+    size_t base = GenericFill(db, params, static_cast<curve*>(in));
+    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to offset_curve_3d"); }    do { // convert the 'basis_curve' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->basis_curve, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to offset_curve_3d to be a `curve`")); }
+    } while (0);
+    do { // convert the 'distance' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->distance, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to offset_curve_3d to be a `length_measure`")); }
+    } while (0);
+    do { // convert the 'self_intersect' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->self_intersect, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to offset_curve_3d to be a `LOGICAL`")); }
+    } while (0);
+    do { // convert the 'ref_direction' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->ref_direction, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to offset_curve_3d to be a `direction`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<offset_surface>(const DB& db, const LIST& params, offset_surface* in)
+{
+    size_t base = GenericFill(db, params, static_cast<surface*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to offset_surface"); }    do { // convert the 'basis_surface' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->basis_surface, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to offset_surface to be a `surface`")); }
+    } while (0);
+    do { // convert the 'distance' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->distance, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to offset_surface to be a `length_measure`")); }
+    } while (0);
+    do { // convert the 'self_intersect' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->self_intersect, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to offset_surface to be a `LOGICAL`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<one_direction_repeat_factor>(const DB& db, const LIST& params, one_direction_repeat_factor* in)
+{
+    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to one_direction_repeat_factor"); }    do { // convert the 'repeat_factor' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::one_direction_repeat_factor, 1>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->repeat_factor, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to one_direction_repeat_factor to be a `vector`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<open_shell>(const DB& db, const LIST& params, open_shell* in)
+{
+    size_t base = GenericFill(db, params, static_cast<connected_face_set*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to open_shell"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<ordinal_date>(const DB& db, const LIST& params, ordinal_date* in)
+{
+    size_t base = GenericFill(db, params, static_cast<date*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to ordinal_date"); }    do { // convert the 'day_component' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->day_component, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to ordinal_date to be a `day_in_year_number`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<projection_directed_callout>(const DB& db, const LIST& params, projection_directed_callout* in)
+{
+    size_t base = GenericFill(db, params, static_cast<draughting_callout*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to projection_directed_callout"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<ordinate_dimension>(const DB& db, const LIST& params, ordinate_dimension* in)
+{
+    size_t base = GenericFill(db, params, static_cast<projection_directed_callout*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to ordinate_dimension"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<organizational_address>(const DB& db, const LIST& params, organizational_address* in)
+{
+    size_t base = GenericFill(db, params, static_cast<address*>(in));
+    if (params.GetSize() < 14) { throw STEP::TypeError("expected 14 arguments to organizational_address"); }    do { // convert the 'organizations' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->organizations, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 12 to organizational_address to be a `SET [1:?] OF organization`")); }
+    } while (0);
+    do { // convert the 'description' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert(in->description, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 13 to organizational_address to be a `text`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<oriented_closed_shell>(const DB& db, const LIST& params, oriented_closed_shell* in)
+{
+    size_t base = GenericFill(db, params, static_cast<closed_shell*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to oriented_closed_shell"); }    do { // convert the 'closed_shell_element' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->closed_shell_element, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to oriented_closed_shell to be a `closed_shell`")); }
+    } while (0);
+    do { // convert the 'orientation' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->orientation, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to oriented_closed_shell to be a `BOOLEAN`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<oriented_edge>(const DB& db, const LIST& params, oriented_edge* in)
+{
+    size_t base = GenericFill(db, params, static_cast<edge*>(in));
+    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to oriented_edge"); }    do { // convert the 'edge_element' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->edge_element, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to oriented_edge to be a `edge`")); }
+    } while (0);
+    do { // convert the 'orientation' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->orientation, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to oriented_edge to be a `BOOLEAN`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<oriented_face>(const DB& db, const LIST& params, oriented_face* in)
+{
+    size_t base = GenericFill(db, params, static_cast<face*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to oriented_face"); }    do { // convert the 'face_element' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->face_element, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to oriented_face to be a `face`")); }
+    } while (0);
+    do { // convert the 'orientation' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->orientation, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to oriented_face to be a `BOOLEAN`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<oriented_open_shell>(const DB& db, const LIST& params, oriented_open_shell* in)
+{
+    size_t base = GenericFill(db, params, static_cast<open_shell*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to oriented_open_shell"); }    do { // convert the 'open_shell_element' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->open_shell_element, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to oriented_open_shell to be a `open_shell`")); }
+    } while (0);
+    do { // convert the 'orientation' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->orientation, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to oriented_open_shell to be a `BOOLEAN`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<path>(const DB& db, const LIST& params, path* in)
+{
+    size_t base = GenericFill(db, params, static_cast<topological_representation_item*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to path"); }    do { // convert the 'edge_list' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::path, 1>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->edge_list, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to path to be a `LIST [1:?] OF oriented_edge`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<oriented_path>(const DB& db, const LIST& params, oriented_path* in)
+{
+    size_t base = GenericFill(db, params, static_cast<path*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to oriented_path"); }    do { // convert the 'path_element' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->path_element, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to oriented_path to be a `path`")); }
+    } while (0);
+    do { // convert the 'orientation' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->orientation, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to oriented_path to be a `BOOLEAN`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<oriented_surface>(const DB& db, const LIST& params, oriented_surface* in)
+{
+    size_t base = GenericFill(db, params, static_cast<surface*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to oriented_surface"); }    do { // convert the 'orientation' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->orientation, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to oriented_surface to be a `BOOLEAN`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<outer_boundary_curve>(const DB& db, const LIST& params, outer_boundary_curve* in)
+{
+    size_t base = GenericFill(db, params, static_cast<boundary_curve*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to outer_boundary_curve"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<package_product_concept_feature>(const DB& db, const LIST& params, package_product_concept_feature* in)
+{
+    size_t base = GenericFill(db, params, static_cast<product_concept_feature*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to package_product_concept_feature"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<parabola>(const DB& db, const LIST& params, parabola* in)
+{
+    size_t base = GenericFill(db, params, static_cast<conic*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to parabola"); }    do { // convert the 'focal_dist' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->focal_dist, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to parabola to be a `length_measure`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<parallel_offset>(const DB& db, const LIST& params, parallel_offset* in)
+{
+    size_t base = GenericFill(db, params, static_cast<derived_shape_aspect*>(in));
+    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to parallel_offset"); }    do { // convert the 'offset' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->offset, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to parallel_offset to be a `measure_with_unit`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<parallelism_tolerance>(const DB& db, const LIST& params, parallelism_tolerance* in)
+{
+    size_t base = GenericFill(db, params, static_cast<geometric_tolerance_with_datum_reference*>(in));
+    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to parallelism_tolerance"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<parametric_representation_context>(const DB& db, const LIST& params, parametric_representation_context* in)
+{
+    size_t base = GenericFill(db, params, static_cast<representation_context*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to parametric_representation_context"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<partial_document_with_structured_text_representation_assignment>(const DB& db, const LIST& params, partial_document_with_structured_text_representation_assignment* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<pcurve>(const DB& db, const LIST& params, pcurve* in)
+{
+    size_t base = GenericFill(db, params, static_cast<curve*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to pcurve"); }    do { // convert the 'basis_surface' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->basis_surface, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to pcurve to be a `surface`")); }
+    } while (0);
+    do { // convert the 'reference_to_curve' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->reference_to_curve, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to pcurve to be a `definitional_representation`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<percentage_laminate_definition>(const DB& db, const LIST& params, percentage_laminate_definition* in)
+{
+    size_t base = GenericFill(db, params, static_cast<product_definition*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to percentage_laminate_definition"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<zone_structural_makeup>(const DB& db, const LIST& params, zone_structural_makeup* in)
+{
+    size_t base = GenericFill(db, params, static_cast<laminate_table*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to zone_structural_makeup"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<percentage_laminate_table>(const DB& db, const LIST& params, percentage_laminate_table* in)
+{
+    size_t base = GenericFill(db, params, static_cast<zone_structural_makeup*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to percentage_laminate_table"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<percentage_ply_definition>(const DB& db, const LIST& params, percentage_ply_definition* in)
+{
+    size_t base = GenericFill(db, params, static_cast<product_definition*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to percentage_ply_definition"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<perpendicular_to>(const DB& db, const LIST& params, perpendicular_to* in)
+{
+    size_t base = GenericFill(db, params, static_cast<derived_shape_aspect*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to perpendicular_to"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<perpendicularity_tolerance>(const DB& db, const LIST& params, perpendicularity_tolerance* in)
+{
+    size_t base = GenericFill(db, params, static_cast<geometric_tolerance_with_datum_reference*>(in));
+    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to perpendicularity_tolerance"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<person_and_organization_address>(const DB& db, const LIST& params, person_and_organization_address* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<personal_address>(const DB& db, const LIST& params, personal_address* in)
+{
+    size_t base = GenericFill(db, params, static_cast<address*>(in));
+    if (params.GetSize() < 14) { throw STEP::TypeError("expected 14 arguments to personal_address"); }    do { // convert the 'people' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->people, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 12 to personal_address to be a `SET [1:?] OF person`")); }
+    } while (0);
+    do { // convert the 'description' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert(in->description, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 13 to personal_address to be a `text`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<physical_breakdown_context>(const DB& db, const LIST& params, physical_breakdown_context* in)
+{
+    size_t base = GenericFill(db, params, static_cast<breakdown_context*>(in));
+    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to physical_breakdown_context"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<physical_element_usage>(const DB& db, const LIST& params, physical_element_usage* in)
+{
+    size_t base = GenericFill(db, params, static_cast<breakdown_element_usage*>(in));
+    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to physical_element_usage"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<presentation_view>(const DB& db, const LIST& params, presentation_view* in)
+{
+    size_t base = GenericFill(db, params, static_cast<presentation_representation*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to presentation_view"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<picture_representation>(const DB& db, const LIST& params, picture_representation* in)
+{
+    size_t base = GenericFill(db, params, static_cast<presentation_view*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to picture_representation"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<placed_datum_target_feature>(const DB& db, const LIST& params, placed_datum_target_feature* in)
+{
+    size_t base = GenericFill(db, params, static_cast<datum_target*>(in));
+    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to placed_datum_target_feature"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<placed_feature>(const DB& db, const LIST& params, placed_feature* in)
+{
+    size_t base = GenericFill(db, params, static_cast<shape_aspect*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to placed_feature"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<planar_extent>(const DB& db, const LIST& params, planar_extent* in)
+{
+    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to planar_extent"); }    do { // convert the 'size_in_x' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::planar_extent, 2>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->size_in_x, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to planar_extent to be a `length_measure`")); }
+    } while (0);
+    do { // convert the 'size_in_y' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::planar_extent, 2>::aux_is_derived[1] = true; break; }
+        try { GenericConvert(in->size_in_y, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to planar_extent to be a `length_measure`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<planar_box>(const DB& db, const LIST& params, planar_box* in)
+{
+    size_t base = GenericFill(db, params, static_cast<planar_extent*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to planar_box"); }    do { // convert the 'placement' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->placement, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to planar_box to be a `axis2_placement`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<plane>(const DB& db, const LIST& params, plane* in)
+{
+    size_t base = GenericFill(db, params, static_cast<elementary_surface*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to plane"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<plane_angle_measure_with_unit>(const DB& db, const LIST& params, plane_angle_measure_with_unit* in)
+{
+    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to plane_angle_measure_with_unit"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<plane_angle_unit>(const DB& db, const LIST& params, plane_angle_unit* in)
+{
+    size_t base = GenericFill(db, params, static_cast<named_unit*>(in));
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to plane_angle_unit"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<ply_laminate_definition>(const DB& db, const LIST& params, ply_laminate_definition* in)
+{
+    size_t base = GenericFill(db, params, static_cast<product_definition*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to ply_laminate_definition"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<ply_laminate_sequence_definition>(const DB& db, const LIST& params, ply_laminate_sequence_definition* in)
+{
+    size_t base = GenericFill(db, params, static_cast<product_definition*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to ply_laminate_sequence_definition"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<ply_laminate_table>(const DB& db, const LIST& params, ply_laminate_table* in)
+{
+    size_t base = GenericFill(db, params, static_cast<part_laminate_table*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to ply_laminate_table"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<point_and_vector>(const DB& db, const LIST& params, point_and_vector* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<point_on_curve>(const DB& db, const LIST& params, point_on_curve* in)
+{
+    size_t base = GenericFill(db, params, static_cast<point*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to point_on_curve"); }    do { // convert the 'basis_curve' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->basis_curve, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to point_on_curve to be a `curve`")); }
+    } while (0);
+    do { // convert the 'point_parameter' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->point_parameter, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to point_on_curve to be a `parameter_value`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<point_on_surface>(const DB& db, const LIST& params, point_on_surface* in)
+{
+    size_t base = GenericFill(db, params, static_cast<point*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to point_on_surface"); }    do { // convert the 'basis_surface' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->basis_surface, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to point_on_surface to be a `surface`")); }
+    } while (0);
+    do { // convert the 'point_parameter_u' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->point_parameter_u, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to point_on_surface to be a `parameter_value`")); }
+    } while (0);
+    do { // convert the 'point_parameter_v' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->point_parameter_v, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to point_on_surface to be a `parameter_value`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<point_path>(const DB& db, const LIST& params, point_path* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<point_replica>(const DB& db, const LIST& params, point_replica* in)
+{
+    size_t base = GenericFill(db, params, static_cast<point*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to point_replica"); }    do { // convert the 'parent_pt' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->parent_pt, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to point_replica to be a `point`")); }
+    } while (0);
+    do { // convert the 'transformation' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->transformation, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to point_replica to be a `cartesian_transformation_operator`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<point_style>(const DB& db, const LIST& params, point_style* in)
+{
+    size_t base = GenericFill(db, params, static_cast<founded_item*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to point_style"); }    do { // convert the 'name' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->name, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to point_style to be a `label`")); }
+    } while (0);
+    do { // convert the 'marker' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->marker, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to point_style to be a `marker_select`")); }
+    } while (0);
+    do { // convert the 'marker_size' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->marker_size, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to point_style to be a `size_select`")); }
+    } while (0);
+    do { // convert the 'marker_colour' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->marker_colour, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to point_style to be a `colour`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<polar_complex_number_literal>(const DB& db, const LIST& params, polar_complex_number_literal* in)
+{
+    size_t base = GenericFill(db, params, static_cast<generic_literal*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to polar_complex_number_literal"); }    do { // convert the 'radius' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::polar_complex_number_literal, 2>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->radius, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to polar_complex_number_literal to be a `REAL`")); }
+    } while (0);
+    do { // convert the 'angle' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::polar_complex_number_literal, 2>::aux_is_derived[1] = true; break; }
+        try { GenericConvert(in->angle, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to polar_complex_number_literal to be a `REAL`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<poly_loop>(const DB& db, const LIST& params, poly_loop* in)
+{
+    size_t base = 0;
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to poly_loop"); }    do { // convert the 'polygon' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->polygon, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to poly_loop to be a `LIST [3:?] OF cartesian_point`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<polyline>(const DB& db, const LIST& params, polyline* in)
+{
+    size_t base = GenericFill(db, params, static_cast<bounded_curve*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to polyline"); }    do { // convert the 'points' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->points, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to polyline to be a `LIST [2:?] OF cartesian_point`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<position_tolerance>(const DB& db, const LIST& params, position_tolerance* in)
+{
+    size_t base = GenericFill(db, params, static_cast<geometric_tolerance*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to position_tolerance"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<positioned_sketch>(const DB& db, const LIST& params, positioned_sketch* in)
+{
+    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to positioned_sketch"); }    do { // convert the 'sketch_basis' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->sketch_basis, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to positioned_sketch to be a `sketch_basis_select`")); }
+    } while (0);
+    do { // convert the 'auxiliary_elements' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->auxiliary_elements, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to positioned_sketch to be a `SET [0:?] OF auxiliary_geometric_representation_item`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<power_measure_with_unit>(const DB& db, const LIST& params, power_measure_with_unit* in)
+{
+    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to power_measure_with_unit"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<power_unit>(const DB& db, const LIST& params, power_unit* in)
+{
+    size_t base = GenericFill(db, params, static_cast<derived_unit*>(in));
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to power_unit"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<pre_defined_symbol>(const DB& db, const LIST& params, pre_defined_symbol* in)
+{
+    size_t base = GenericFill(db, params, static_cast<pre_defined_item*>(in));
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to pre_defined_symbol"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<pre_defined_dimension_symbol>(const DB& db, const LIST& params, pre_defined_dimension_symbol* in)
+{
+    size_t base = GenericFill(db, params, static_cast<pre_defined_symbol*>(in));
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to pre_defined_dimension_symbol"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<pre_defined_geometrical_tolerance_symbol>(const DB& db, const LIST& params, pre_defined_geometrical_tolerance_symbol* in)
+{
+    size_t base = GenericFill(db, params, static_cast<pre_defined_symbol*>(in));
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to pre_defined_geometrical_tolerance_symbol"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<pre_defined_marker>(const DB& db, const LIST& params, pre_defined_marker* in)
+{
+    size_t base = GenericFill(db, params, static_cast<pre_defined_item*>(in));
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to pre_defined_marker"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<pre_defined_point_marker_symbol>(const DB& db, const LIST& params, pre_defined_point_marker_symbol* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<pre_defined_surface_condition_symbol>(const DB& db, const LIST& params, pre_defined_surface_condition_symbol* in)
+{
+    size_t base = GenericFill(db, params, static_cast<pre_defined_symbol*>(in));
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to pre_defined_surface_condition_symbol"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<pre_defined_surface_side_style>(const DB& db, const LIST& params, pre_defined_surface_side_style* in)
+{
+    size_t base = GenericFill(db, params, static_cast<pre_defined_item*>(in));
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to pre_defined_surface_side_style"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<pre_defined_terminator_symbol>(const DB& db, const LIST& params, pre_defined_terminator_symbol* in)
+{
+    size_t base = GenericFill(db, params, static_cast<pre_defined_symbol*>(in));
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to pre_defined_terminator_symbol"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<pre_defined_tile>(const DB& db, const LIST& params, pre_defined_tile* in)
+{
+    size_t base = GenericFill(db, params, static_cast<pre_defined_item*>(in));
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to pre_defined_tile"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<predefined_picture_representation_item>(const DB& db, const LIST& params, predefined_picture_representation_item* in)
+{
+    size_t base = GenericFill(db, params, static_cast<picture_representation_item*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to predefined_picture_representation_item"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<presentation_style_assignment>(const DB& db, const LIST& params, presentation_style_assignment* in)
+{
+    size_t base = GenericFill(db, params, static_cast<founded_item*>(in));
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to presentation_style_assignment"); }    do { // convert the 'styles' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::presentation_style_assignment, 1>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->styles, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to presentation_style_assignment to be a `SET [1:?] OF presentation_style_select`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<presentation_style_by_context>(const DB& db, const LIST& params, presentation_style_by_context* in)
+{
+    size_t base = GenericFill(db, params, static_cast<presentation_style_assignment*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to presentation_style_by_context"); }    do { // convert the 'style_context' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->style_context, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to presentation_style_by_context to be a `style_context_select`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<pressure_measure_with_unit>(const DB& db, const LIST& params, pressure_measure_with_unit* in)
+{
+    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to pressure_measure_with_unit"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<pressure_unit>(const DB& db, const LIST& params, pressure_unit* in)
+{
+    size_t base = GenericFill(db, params, static_cast<derived_unit*>(in));
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to pressure_unit"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<procedural_representation>(const DB& db, const LIST& params, procedural_representation* in)
+{
+    size_t base = GenericFill(db, params, static_cast<representation*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to procedural_representation"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<procedural_representation_sequence>(const DB& db, const LIST& params, procedural_representation_sequence* in)
+{
+    size_t base = GenericFill(db, params, static_cast<representation_item*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to procedural_representation_sequence"); }    do { // convert the 'elements' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->elements, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to procedural_representation_sequence to be a `LIST [1:?] OF representation_item`")); }
+    } while (0);
+    do { // convert the 'suppressed_items' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->suppressed_items, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to procedural_representation_sequence to be a `SET [0:?] OF representation_item`")); }
+    } while (0);
+    do { // convert the 'rationale' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->rationale, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to procedural_representation_sequence to be a `text`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<procedural_shape_representation>(const DB& db, const LIST& params, procedural_shape_representation* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<procedural_shape_representation_sequence>(const DB& db, const LIST& params, procedural_shape_representation_sequence* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<product_category>(const DB& db, const LIST& params, product_category* in)
+{
+    size_t base = 0;
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to product_category"); }    do { // convert the 'name' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::product_category, 2>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->name, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to product_category to be a `label`")); }
+    } while (0);
+    do { // convert the 'description' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::product_category, 2>::aux_is_derived[1] = true; break; }
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert(in->description, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to product_category to be a `text`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<product_class>(const DB& db, const LIST& params, product_class* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<product_concept_context>(const DB& db, const LIST& params, product_concept_context* in)
+{
+    size_t base = GenericFill(db, params, static_cast<application_context_element*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to product_concept_context"); }    do { // convert the 'market_segment_type' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->market_segment_type, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to product_concept_context to be a `label`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<product_concept_feature_category_usage>(const DB& db, const LIST& params, product_concept_feature_category_usage* in)
+{
+    size_t base = GenericFill(db, params, static_cast<group_assignment*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to product_concept_feature_category_usage"); }    do { // convert the 'items' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->items, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to product_concept_feature_category_usage to be a `SET [1:?] OF category_usage_item`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<product_definition_element_relationship>(const DB& db, const LIST& params, product_definition_element_relationship* in)
+{
+    size_t base = GenericFill(db, params, static_cast<group*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to product_definition_element_relationship"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<product_definition_formation>(const DB& db, const LIST& params, product_definition_formation* in)
+{
+    size_t base = 0;
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to product_definition_formation"); }    do { // convert the 'id' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::product_definition_formation, 3>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->id, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to product_definition_formation to be a `identifier`")); }
+    } while (0);
+    do { // convert the 'description' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::product_definition_formation, 3>::aux_is_derived[1] = true; break; }
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert(in->description, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to product_definition_formation to be a `text`")); }
+    } while (0);
+    do { // convert the 'of_product' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::product_definition_formation, 3>::aux_is_derived[2] = true; break; }
+        try { GenericConvert(in->of_product, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to product_definition_formation to be a `product`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<product_definition_formation_with_specified_source>(const DB& db, const LIST& params, product_definition_formation_with_specified_source* in)
+{
+    size_t base = GenericFill(db, params, static_cast<product_definition_formation*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to product_definition_formation_with_specified_source"); }    do { // convert the 'make_or_buy' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->make_or_buy, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to product_definition_formation_with_specified_source to be a `source`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<product_definition_group_assignment>(const DB& db, const LIST& params, product_definition_group_assignment* in)
+{
+    size_t base = GenericFill(db, params, static_cast<group_assignment*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to product_definition_group_assignment"); }    do { // convert the 'items' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->items, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to product_definition_group_assignment to be a `SET [1:1] OF product_definition_or_product_definition_relationship`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<product_definition_shape>(const DB& db, const LIST& params, product_definition_shape* in)
+{
+    size_t base = GenericFill(db, params, static_cast<property_definition*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to product_definition_shape"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<product_definition_with_associated_documents>(const DB& db, const LIST& params, product_definition_with_associated_documents* in)
+{
+    size_t base = GenericFill(db, params, static_cast<product_definition*>(in));
+    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to product_definition_with_associated_documents"); }    do { // convert the 'documentation_ids' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->documentation_ids, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to product_definition_with_associated_documents to be a `SET [1:?] OF document`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<product_identification>(const DB& db, const LIST& params, product_identification* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<product_material_composition_relationship>(const DB& db, const LIST& params, product_material_composition_relationship* in)
+{
+    size_t base = GenericFill(db, params, static_cast<product_definition_relationship*>(in));
+    if (params.GetSize() < 9) { throw STEP::TypeError("expected 9 arguments to product_material_composition_relationship"); }    do { // convert the 'class' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->class_, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to product_material_composition_relationship to be a `label`")); }
+    } while (0);
+    do { // convert the 'constituent_amount' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->constituent_amount, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to product_material_composition_relationship to be a `SET [1:?] OF characterized_product_composition_value`")); }
+    } while (0);
+    do { // convert the 'composition_basis' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->composition_basis, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to product_material_composition_relationship to be a `label`")); }
+    } while (0);
+    do { // convert the 'determination_method' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->determination_method, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 8 to product_material_composition_relationship to be a `text`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<product_related_product_category>(const DB& db, const LIST& params, product_related_product_category* in)
+{
+    size_t base = GenericFill(db, params, static_cast<product_category*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to product_related_product_category"); }    do { // convert the 'products' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->products, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to product_related_product_category to be a `SET [1:?] OF product`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<product_specification>(const DB& db, const LIST& params, product_specification* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<tolerance_zone_definition>(const DB& db, const LIST& params, tolerance_zone_definition* in)
+{
+    size_t base = 0;
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to tolerance_zone_definition"); }    do { // convert the 'zone' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::tolerance_zone_definition, 2>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->zone, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to tolerance_zone_definition to be a `tolerance_zone`")); }
+    } while (0);
+    do { // convert the 'boundaries' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::tolerance_zone_definition, 2>::aux_is_derived[1] = true; break; }
+        try { GenericConvert(in->boundaries, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to tolerance_zone_definition to be a `SET [1:?] OF shape_aspect`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<projected_zone_definition>(const DB& db, const LIST& params, projected_zone_definition* in)
+{
+    size_t base = GenericFill(db, params, static_cast<tolerance_zone_definition*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to projected_zone_definition"); }    do { // convert the 'projection_end' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->projection_end, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to projected_zone_definition to be a `shape_aspect`")); }
+    } while (0);
+    do { // convert the 'projected_length' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->projected_length, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to projected_zone_definition to be a `measure_with_unit`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<projection_curve>(const DB& db, const LIST& params, projection_curve* in)
+{
+    size_t base = GenericFill(db, params, static_cast<annotation_curve_occurrence*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to projection_curve"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<promissory_usage_occurrence>(const DB& db, const LIST& params, promissory_usage_occurrence* in)
+{
+    size_t base = GenericFill(db, params, static_cast<assembly_component_usage*>(in));
+    if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to promissory_usage_occurrence"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<qualified_representation_item>(const DB& db, const LIST& params, qualified_representation_item* in)
+{
+    size_t base = GenericFill(db, params, static_cast<representation_item*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to qualified_representation_item"); }    do { // convert the 'qualifiers' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->qualifiers, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to qualified_representation_item to be a `SET [1:?] OF value_qualifier`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<qualitative_uncertainty>(const DB& db, const LIST& params, qualitative_uncertainty* in)
+{
+    size_t base = GenericFill(db, params, static_cast<uncertainty_qualifier*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to qualitative_uncertainty"); }    do { // convert the 'uncertainty_value' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->uncertainty_value, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to qualitative_uncertainty to be a `text`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<quantified_assembly_component_usage>(const DB& db, const LIST& params, quantified_assembly_component_usage* in)
+{
+    size_t base = GenericFill(db, params, static_cast<assembly_component_usage*>(in));
+    if (params.GetSize() < 7) { throw STEP::TypeError("expected 7 arguments to quantified_assembly_component_usage"); }    do { // convert the 'quantity' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->quantity, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to quantified_assembly_component_usage to be a `measure_with_unit`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<quasi_uniform_curve>(const DB& db, const LIST& params, quasi_uniform_curve* in)
+{
+    size_t base = GenericFill(db, params, static_cast<b_spline_curve*>(in));
+    if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to quasi_uniform_curve"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<quasi_uniform_surface>(const DB& db, const LIST& params, quasi_uniform_surface* in)
+{
+    size_t base = GenericFill(db, params, static_cast<b_spline_surface*>(in));
+    if (params.GetSize() < 7) { throw STEP::TypeError("expected 7 arguments to quasi_uniform_surface"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<radioactivity_measure_with_unit>(const DB& db, const LIST& params, radioactivity_measure_with_unit* in)
+{
+    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to radioactivity_measure_with_unit"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<radioactivity_unit>(const DB& db, const LIST& params, radioactivity_unit* in)
+{
+    size_t base = GenericFill(db, params, static_cast<derived_unit*>(in));
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to radioactivity_unit"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<radius_dimension>(const DB& db, const LIST& params, radius_dimension* in)
+{
+    size_t base = GenericFill(db, params, static_cast<dimension_curve_directed_callout*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to radius_dimension"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<range_characteristic>(const DB& db, const LIST& params, range_characteristic* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<ratio_unit>(const DB& db, const LIST& params, ratio_unit* in)
+{
+    size_t base = GenericFill(db, params, static_cast<named_unit*>(in));
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to ratio_unit"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<rational_b_spline_curve>(const DB& db, const LIST& params, rational_b_spline_curve* in)
+{
+    size_t base = GenericFill(db, params, static_cast<b_spline_curve*>(in));
+    if (params.GetSize() < 7) { throw STEP::TypeError("expected 7 arguments to rational_b_spline_curve"); }    do { // convert the 'weights_data' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->weights_data, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to rational_b_spline_curve to be a `LIST [2:?] OF REAL`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<rational_b_spline_surface>(const DB& db, const LIST& params, rational_b_spline_surface* in)
+{
+    size_t base = GenericFill(db, params, static_cast<b_spline_surface*>(in));
+    if (params.GetSize() < 7) { throw STEP::TypeError("expected 7 arguments to rational_b_spline_surface"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<rational_representation_item>(const DB& db, const LIST& params, rational_representation_item* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<real_literal>(const DB& db, const LIST& params, real_literal* in)
+{
+    size_t base = GenericFill(db, params, static_cast<literal_number*>(in));
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to real_literal"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<real_representation_item>(const DB& db, const LIST& params, real_representation_item* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<rectangular_composite_surface>(const DB& db, const LIST& params, rectangular_composite_surface* in)
+{
+    size_t base = GenericFill(db, params, static_cast<bounded_surface*>(in));
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to rectangular_composite_surface"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<rectangular_trimmed_surface>(const DB& db, const LIST& params, rectangular_trimmed_surface* in)
+{
+    size_t base = GenericFill(db, params, static_cast<bounded_surface*>(in));
+    if (params.GetSize() < 8) { throw STEP::TypeError("expected 8 arguments to rectangular_trimmed_surface"); }    do { // convert the 'basis_surface' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->basis_surface, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to rectangular_trimmed_surface to be a `surface`")); }
+    } while (0);
+    do { // convert the 'u1' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->u1, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to rectangular_trimmed_surface to be a `parameter_value`")); }
+    } while (0);
+    do { // convert the 'u2' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->u2, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to rectangular_trimmed_surface to be a `parameter_value`")); }
+    } while (0);
+    do { // convert the 'v1' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->v1, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to rectangular_trimmed_surface to be a `parameter_value`")); }
+    } while (0);
+    do { // convert the 'v2' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->v2, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to rectangular_trimmed_surface to be a `parameter_value`")); }
+    } while (0);
+    do { // convert the 'usense' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->usense, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to rectangular_trimmed_surface to be a `BOOLEAN`")); }
+    } while (0);
+    do { // convert the 'vsense' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->vsense, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to rectangular_trimmed_surface to be a `BOOLEAN`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<referenced_modified_datum>(const DB& db, const LIST& params, referenced_modified_datum* in)
+{
+    size_t base = GenericFill(db, params, static_cast<datum_reference*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to referenced_modified_datum"); }    do { // convert the 'modifier' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->modifier, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to referenced_modified_datum to be a `limit_condition`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<relative_event_occurrence>(const DB& db, const LIST& params, relative_event_occurrence* in)
+{
+    size_t base = GenericFill(db, params, static_cast<event_occurrence*>(in));
+    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to relative_event_occurrence"); }    do { // convert the 'base_event' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->base_event, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to relative_event_occurrence to be a `event_occurrence`")); }
+    } while (0);
+    do { // convert the 'offset' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->offset, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to relative_event_occurrence to be a `time_measure_with_unit`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<rep_item_group>(const DB& db, const LIST& params, rep_item_group* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<reparametrised_composite_curve_segment>(const DB& db, const LIST& params, reparametrised_composite_curve_segment* in)
+{
+    size_t base = GenericFill(db, params, static_cast<composite_curve_segment*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to reparametrised_composite_curve_segment"); }    do { // convert the 'param_length' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->param_length, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to reparametrised_composite_curve_segment to be a `parameter_value`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<representation_relationship_with_transformation>(const DB& db, const LIST& params, representation_relationship_with_transformation* in)
+{
+    size_t base = GenericFill(db, params, static_cast<representation_relationship*>(in));
+    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to representation_relationship_with_transformation"); }    do { // convert the 'transformation_operator' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->transformation_operator, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to representation_relationship_with_transformation to be a `transformation`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<requirement_assigned_object>(const DB& db, const LIST& params, requirement_assigned_object* in)
+{
+    size_t base = GenericFill(db, params, static_cast<group_assignment*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to requirement_assigned_object"); }    do { // convert the 'items' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->items, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to requirement_assigned_object to be a `SET [1:1] OF requirement_assigned_item`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<requirement_assignment>(const DB& db, const LIST& params, requirement_assignment* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<requirement_source>(const DB& db, const LIST& params, requirement_source* in)
+{
+    size_t base = GenericFill(db, params, static_cast<group*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to requirement_source"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<requirement_view_definition_relationship>(const DB& db, const LIST& params, requirement_view_definition_relationship* in)
+{
+    size_t base = GenericFill(db, params, static_cast<product_definition_relationship*>(in));
+    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to requirement_view_definition_relationship"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<resistance_measure_with_unit>(const DB& db, const LIST& params, resistance_measure_with_unit* in)
+{
+    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to resistance_measure_with_unit"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<resistance_unit>(const DB& db, const LIST& params, resistance_unit* in)
+{
+    size_t base = GenericFill(db, params, static_cast<derived_unit*>(in));
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to resistance_unit"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<revolved_area_solid>(const DB& db, const LIST& params, revolved_area_solid* in)
+{
+    size_t base = GenericFill(db, params, static_cast<swept_area_solid*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to revolved_area_solid"); }    do { // convert the 'axis' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->axis, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to revolved_area_solid to be a `axis1_placement`")); }
+    } while (0);
+    do { // convert the 'angle' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->angle, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to revolved_area_solid to be a `plane_angle_measure`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<revolved_face_solid>(const DB& db, const LIST& params, revolved_face_solid* in)
+{
+    size_t base = GenericFill(db, params, static_cast<swept_face_solid*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to revolved_face_solid"); }    do { // convert the 'axis' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::revolved_face_solid, 2>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->axis, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to revolved_face_solid to be a `axis1_placement`")); }
+    } while (0);
+    do { // convert the 'angle' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::revolved_face_solid, 2>::aux_is_derived[1] = true; break; }
+        try { GenericConvert(in->angle, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to revolved_face_solid to be a `plane_angle_measure`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<revolved_face_solid_with_trim_conditions>(const DB& db, const LIST& params, revolved_face_solid_with_trim_conditions* in)
+{
+    size_t base = GenericFill(db, params, static_cast<revolved_face_solid*>(in));
+    if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to revolved_face_solid_with_trim_conditions"); }    do { // convert the 'first_trim_condition' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->first_trim_condition, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to revolved_face_solid_with_trim_conditions to be a `trim_condition_select`")); }
+    } while (0);
+    do { // convert the 'second_trim_condition' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->second_trim_condition, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to revolved_face_solid_with_trim_conditions to be a `trim_condition_select`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<right_angular_wedge>(const DB& db, const LIST& params, right_angular_wedge* in)
+{
+    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
+    if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to right_angular_wedge"); }    do { // convert the 'position' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->position, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to right_angular_wedge to be a `axis2_placement_3d`")); }
+    } while (0);
+    do { // convert the 'x' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->x, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to right_angular_wedge to be a `positive_length_measure`")); }
+    } while (0);
+    do { // convert the 'y' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->y, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to right_angular_wedge to be a `positive_length_measure`")); }
+    } while (0);
+    do { // convert the 'z' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->z, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to right_angular_wedge to be a `positive_length_measure`")); }
+    } while (0);
+    do { // convert the 'ltx' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->ltx, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to right_angular_wedge to be a `length_measure`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<right_circular_cone>(const DB& db, const LIST& params, right_circular_cone* in)
+{
+    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
+    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to right_circular_cone"); }    do { // convert the 'position' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->position, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to right_circular_cone to be a `axis1_placement`")); }
+    } while (0);
+    do { // convert the 'height' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->height, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to right_circular_cone to be a `positive_length_measure`")); }
+    } while (0);
+    do { // convert the 'radius' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->radius, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to right_circular_cone to be a `length_measure`")); }
+    } while (0);
+    do { // convert the 'semi_angle' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->semi_angle, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to right_circular_cone to be a `plane_angle_measure`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<right_circular_cylinder>(const DB& db, const LIST& params, right_circular_cylinder* in)
+{
+    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to right_circular_cylinder"); }    do { // convert the 'position' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->position, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to right_circular_cylinder to be a `axis1_placement`")); }
+    } while (0);
+    do { // convert the 'height' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->height, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to right_circular_cylinder to be a `positive_length_measure`")); }
+    } while (0);
+    do { // convert the 'radius' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->radius, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to right_circular_cylinder to be a `positive_length_measure`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<right_to_usage_association>(const DB& db, const LIST& params, right_to_usage_association* in)
+{
+    size_t base = GenericFill(db, params, static_cast<action_method_relationship*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to right_to_usage_association"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<roundness_tolerance>(const DB& db, const LIST& params, roundness_tolerance* in)
+{
+    size_t base = GenericFill(db, params, static_cast<geometric_tolerance*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to roundness_tolerance"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<row_representation_item>(const DB& db, const LIST& params, row_representation_item* in)
+{
+    size_t base = GenericFill(db, params, static_cast<compound_representation_item*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to row_representation_item"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<row_value>(const DB& db, const LIST& params, row_value* in)
+{
+    size_t base = GenericFill(db, params, static_cast<compound_representation_item*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to row_value"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<row_variable>(const DB& db, const LIST& params, row_variable* in)
+{
+    size_t base = GenericFill(db, params, static_cast<abstract_variable*>(in));
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<rule_action>(const DB& db, const LIST& params, rule_action* in)
+{
+    size_t base = GenericFill(db, params, static_cast<action*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to rule_action"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<rule_condition>(const DB& db, const LIST& params, rule_condition* in)
+{
+    size_t base = GenericFill(db, params, static_cast<atomic_formula*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to rule_condition"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<rule_set>(const DB& db, const LIST& params, rule_set* in)
+{
+    size_t base = GenericFill(db, params, static_cast<rule_software_definition*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to rule_set"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<rule_set_group>(const DB& db, const LIST& params, rule_set_group* in)
+{
+    size_t base = GenericFill(db, params, static_cast<rule_software_definition*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to rule_set_group"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<rule_superseded_assignment>(const DB& db, const LIST& params, rule_superseded_assignment* in)
+{
+    size_t base = GenericFill(db, params, static_cast<action_assignment*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to rule_superseded_assignment"); }    do { // convert the 'items' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->items, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to rule_superseded_assignment to be a `SET [1:?] OF rule_superseded_item`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<rule_supersedence>(const DB& db, const LIST& params, rule_supersedence* in)
+{
+    size_t base = GenericFill(db, params, static_cast<rule_action*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to rule_supersedence"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<surface_curve_swept_area_solid>(const DB& db, const LIST& params, surface_curve_swept_area_solid* in)
+{
+    size_t base = GenericFill(db, params, static_cast<swept_area_solid*>(in));
+    if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to surface_curve_swept_area_solid"); }    do { // convert the 'directrix' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::surface_curve_swept_area_solid, 4>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->directrix, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to surface_curve_swept_area_solid to be a `curve`")); }
+    } while (0);
+    do { // convert the 'start_param' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::surface_curve_swept_area_solid, 4>::aux_is_derived[1] = true; break; }
+        try { GenericConvert(in->start_param, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to surface_curve_swept_area_solid to be a `REAL`")); }
+    } while (0);
+    do { // convert the 'end_param' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::surface_curve_swept_area_solid, 4>::aux_is_derived[2] = true; break; }
+        try { GenericConvert(in->end_param, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to surface_curve_swept_area_solid to be a `REAL`")); }
+    } while (0);
+    do { // convert the 'reference_surface' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::surface_curve_swept_area_solid, 4>::aux_is_derived[3] = true; break; }
+        try { GenericConvert(in->reference_surface, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to surface_curve_swept_area_solid to be a `surface`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<ruled_surface_swept_area_solid>(const DB& db, const LIST& params, ruled_surface_swept_area_solid* in)
+{
+    size_t base = GenericFill(db, params, static_cast<surface_curve_swept_area_solid*>(in));
+    if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to ruled_surface_swept_area_solid"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<runout_zone_definition>(const DB& db, const LIST& params, runout_zone_definition* in)
+{
+    size_t base = GenericFill(db, params, static_cast<tolerance_zone_definition*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to runout_zone_definition"); }    do { // convert the 'orientation' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->orientation, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to runout_zone_definition to be a `runout_zone_orientation`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<runout_zone_orientation>(const DB& db, const LIST& params, runout_zone_orientation* in)
+{
+    size_t base = 0;
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to runout_zone_orientation"); }    do { // convert the 'angle' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::runout_zone_orientation, 1>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->angle, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to runout_zone_orientation to be a `measure_with_unit`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<runout_zone_orientation_reference_direction>(const DB& db, const LIST& params, runout_zone_orientation_reference_direction* in)
+{
+    size_t base = GenericFill(db, params, static_cast<runout_zone_orientation*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to runout_zone_orientation_reference_direction"); }    do { // convert the 'orientation_defining_relationship' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->orientation_defining_relationship, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to runout_zone_orientation_reference_direction to be a `shape_aspect_relationship`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<satisfied_requirement>(const DB& db, const LIST& params, satisfied_requirement* in)
+{
+    size_t base = GenericFill(db, params, static_cast<group_assignment*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to satisfied_requirement"); }    do { // convert the 'items' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->items, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to satisfied_requirement to be a `SET [1:1] OF product_definition`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<satisfies_requirement>(const DB& db, const LIST& params, satisfies_requirement* in)
+{
+    size_t base = GenericFill(db, params, static_cast<group*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to satisfies_requirement"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<satisfying_item>(const DB& db, const LIST& params, satisfying_item* in)
+{
+    size_t base = GenericFill(db, params, static_cast<group_assignment*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to satisfying_item"); }    do { // convert the 'items' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->items, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to satisfying_item to be a `SET [1:1] OF requirement_satisfaction_item`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<scalar_variable>(const DB& db, const LIST& params, scalar_variable* in)
+{
+    size_t base = GenericFill(db, params, static_cast<abstract_variable*>(in));
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<scattering_parameter>(const DB& db, const LIST& params, scattering_parameter* in)
+{
+    size_t base = GenericFill(db, params, static_cast<polar_complex_number_literal*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to scattering_parameter"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<sculptured_solid>(const DB& db, const LIST& params, sculptured_solid* in)
+{
+    size_t base = GenericFill(db, params, static_cast<modified_solid*>(in));
+    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to sculptured_solid"); }    do { // convert the 'sculpturing_element' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->sculpturing_element, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to sculptured_solid to be a `generalized_surface_select`")); }
+    } while (0);
+    do { // convert the 'positive_side' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->positive_side, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to sculptured_solid to be a `BOOLEAN`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<seam_curve>(const DB& db, const LIST& params, seam_curve* in)
+{
+    size_t base = GenericFill(db, params, static_cast<surface_curve*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to seam_curve"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<serial_numbered_effectivity>(const DB& db, const LIST& params, serial_numbered_effectivity* in)
+{
+    size_t base = GenericFill(db, params, static_cast<effectivity*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to serial_numbered_effectivity"); }    do { // convert the 'effectivity_start_id' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->effectivity_start_id, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to serial_numbered_effectivity to be a `identifier`")); }
+    } while (0);
+    do { // convert the 'effectivity_end_id' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert(in->effectivity_end_id, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to serial_numbered_effectivity to be a `identifier`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<shape_aspect_associativity>(const DB& db, const LIST& params, shape_aspect_associativity* in)
+{
+    size_t base = GenericFill(db, params, static_cast<shape_aspect_relationship*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to shape_aspect_associativity"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<shape_aspect_deriving_relationship>(const DB& db, const LIST& params, shape_aspect_deriving_relationship* in)
+{
+    size_t base = GenericFill(db, params, static_cast<shape_aspect_relationship*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to shape_aspect_deriving_relationship"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<shape_definition_representation>(const DB& db, const LIST& params, shape_definition_representation* in)
+{
+    size_t base = GenericFill(db, params, static_cast<property_definition_representation*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to shape_definition_representation"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<shape_dimension_representation>(const DB& db, const LIST& params, shape_dimension_representation* in)
+{
+    size_t base = GenericFill(db, params, static_cast<shape_representation*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to shape_dimension_representation"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<shape_feature_definition>(const DB& db, const LIST& params, shape_feature_definition* in)
+{
+    size_t base = GenericFill(db, params, static_cast<characterized_object*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to shape_feature_definition"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<shape_representation_with_parameters>(const DB& db, const LIST& params, shape_representation_with_parameters* in)
+{
+    size_t base = GenericFill(db, params, static_cast<shape_representation*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to shape_representation_with_parameters"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<shell_based_surface_model>(const DB& db, const LIST& params, shell_based_surface_model* in)
+{
+    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to shell_based_surface_model"); }    do { // convert the 'sbsm_boundary' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->sbsm_boundary, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to shell_based_surface_model to be a `SET [1:?] OF shell`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<shell_based_wireframe_model>(const DB& db, const LIST& params, shell_based_wireframe_model* in)
+{
+    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to shell_based_wireframe_model"); }    do { // convert the 'sbwm_boundary' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->sbwm_boundary, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to shell_based_wireframe_model to be a `SET [1:?] OF shell`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<shell_based_wireframe_shape_representation>(const DB& db, const LIST& params, shell_based_wireframe_shape_representation* in)
+{
+    size_t base = GenericFill(db, params, static_cast<shape_representation*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to shell_based_wireframe_shape_representation"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<si_absorbed_dose_unit>(const DB& db, const LIST& params, si_absorbed_dose_unit* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<si_capacitance_unit>(const DB& db, const LIST& params, si_capacitance_unit* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<si_conductance_unit>(const DB& db, const LIST& params, si_conductance_unit* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<si_dose_equivalent_unit>(const DB& db, const LIST& params, si_dose_equivalent_unit* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<si_electric_charge_unit>(const DB& db, const LIST& params, si_electric_charge_unit* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<si_electric_potential_unit>(const DB& db, const LIST& params, si_electric_potential_unit* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<si_energy_unit>(const DB& db, const LIST& params, si_energy_unit* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<si_force_unit>(const DB& db, const LIST& params, si_force_unit* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<si_frequency_unit>(const DB& db, const LIST& params, si_frequency_unit* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<si_illuminance_unit>(const DB& db, const LIST& params, si_illuminance_unit* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<si_inductance_unit>(const DB& db, const LIST& params, si_inductance_unit* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<si_magnetic_flux_density_unit>(const DB& db, const LIST& params, si_magnetic_flux_density_unit* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<si_magnetic_flux_unit>(const DB& db, const LIST& params, si_magnetic_flux_unit* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<si_power_unit>(const DB& db, const LIST& params, si_power_unit* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<si_pressure_unit>(const DB& db, const LIST& params, si_pressure_unit* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<si_radioactivity_unit>(const DB& db, const LIST& params, si_radioactivity_unit* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<si_resistance_unit>(const DB& db, const LIST& params, si_resistance_unit* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<si_unit>(const DB& db, const LIST& params, si_unit* in)
+{
+    size_t base = GenericFill(db, params, static_cast<named_unit*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to si_unit"); }    do { // convert the 'prefix' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert(in->prefix, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to si_unit to be a `si_prefix`")); }
+    } while (0);
+    do { // convert the 'name' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->name, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to si_unit to be a `si_unit_name`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<simple_boolean_expression>(const DB& db, const LIST& params, simple_boolean_expression* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<simple_numeric_expression>(const DB& db, const LIST& params, simple_numeric_expression* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<slash_expression>(const DB& db, const LIST& params, slash_expression* in)
+{
+    size_t base = GenericFill(db, params, static_cast<binary_numeric_expression*>(in));
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<smeared_material_definition>(const DB& db, const LIST& params, smeared_material_definition* in)
+{
+    size_t base = GenericFill(db, params, static_cast<zone_structural_makeup*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to smeared_material_definition"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<solid_angle_measure_with_unit>(const DB& db, const LIST& params, solid_angle_measure_with_unit* in)
+{
+    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to solid_angle_measure_with_unit"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<solid_angle_unit>(const DB& db, const LIST& params, solid_angle_unit* in)
+{
+    size_t base = GenericFill(db, params, static_cast<named_unit*>(in));
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to solid_angle_unit"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<solid_curve_font>(const DB& db, const LIST& params, solid_curve_font* in)
+{
+    size_t base = GenericFill(db, params, static_cast<pre_defined_curve_font*>(in));
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to solid_curve_font"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<solid_replica>(const DB& db, const LIST& params, solid_replica* in)
+{
+    size_t base = GenericFill(db, params, static_cast<solid_model*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to solid_replica"); }    do { // convert the 'parent_solid' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->parent_solid, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to solid_replica to be a `solid_model`")); }
+    } while (0);
+    do { // convert the 'transformation' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->transformation, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to solid_replica to be a `cartesian_transformation_operator_3d`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<solid_with_chamfered_edges>(const DB& db, const LIST& params, solid_with_chamfered_edges* in)
+{
+    size_t base = GenericFill(db, params, static_cast<edge_blended_solid*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to solid_with_chamfered_edges"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<solid_with_angle_based_chamfer>(const DB& db, const LIST& params, solid_with_angle_based_chamfer* in)
+{
+    size_t base = GenericFill(db, params, static_cast<solid_with_chamfered_edges*>(in));
+    if (params.GetSize() < 7) { throw STEP::TypeError("expected 7 arguments to solid_with_angle_based_chamfer"); }    do { // convert the 'offset_distance' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->offset_distance, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to solid_with_angle_based_chamfer to be a `positive_length_measure`")); }
+    } while (0);
+    do { // convert the 'left_offset' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->left_offset, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to solid_with_angle_based_chamfer to be a `BOOLEAN`")); }
+    } while (0);
+    do { // convert the 'offset_angle' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->offset_angle, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to solid_with_angle_based_chamfer to be a `positive_plane_angle_measure`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<solid_with_shape_element_pattern>(const DB& db, const LIST& params, solid_with_shape_element_pattern* in)
+{
+    size_t base = GenericFill(db, params, static_cast<modified_solid_with_placed_configuration*>(in));
+    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to solid_with_shape_element_pattern"); }    do { // convert the 'replicated_element' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::solid_with_shape_element_pattern, 1>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->replicated_element, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to solid_with_shape_element_pattern to be a `modified_solid_with_placed_configuration`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<solid_with_circular_pattern>(const DB& db, const LIST& params, solid_with_circular_pattern* in)
+{
+    size_t base = GenericFill(db, params, static_cast<solid_with_shape_element_pattern*>(in));
+    if (params.GetSize() < 9) { throw STEP::TypeError("expected 9 arguments to solid_with_circular_pattern"); }    do { // convert the 'replicate_count' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::solid_with_circular_pattern, 4>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->replicate_count, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to solid_with_circular_pattern to be a `positive_integer`")); }
+    } while (0);
+    do { // convert the 'angular_spacing' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::solid_with_circular_pattern, 4>::aux_is_derived[1] = true; break; }
+        try { GenericConvert(in->angular_spacing, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to solid_with_circular_pattern to be a `plane_angle_measure`")); }
+    } while (0);
+    do { // convert the 'radial_alignment' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::solid_with_circular_pattern, 4>::aux_is_derived[2] = true; break; }
+        try { GenericConvert(in->radial_alignment, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to solid_with_circular_pattern to be a `BOOLEAN`")); }
+    } while (0);
+    do { // convert the 'reference_point' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::solid_with_circular_pattern, 4>::aux_is_derived[3] = true; break; }
+        try { GenericConvert(in->reference_point, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 8 to solid_with_circular_pattern to be a `point`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<solid_with_depression>(const DB& db, const LIST& params, solid_with_depression* in)
+{
+    size_t base = GenericFill(db, params, static_cast<modified_solid_with_placed_configuration*>(in));
+    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to solid_with_depression"); }    do { // convert the 'depth' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::solid_with_depression, 1>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->depth, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to solid_with_depression to be a `positive_length_measure`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<solid_with_pocket>(const DB& db, const LIST& params, solid_with_pocket* in)
+{
+    size_t base = GenericFill(db, params, static_cast<solid_with_depression*>(in));
+    if (params.GetSize() < 7) { throw STEP::TypeError("expected 7 arguments to solid_with_pocket"); }    do { // convert the 'floor_blend_radius' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::solid_with_pocket, 2>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->floor_blend_radius, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to solid_with_pocket to be a `non_negative_length_measure`")); }
+    } while (0);
+    do { // convert the 'draft_angle' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::solid_with_pocket, 2>::aux_is_derived[1] = true; break; }
+        try { GenericConvert(in->draft_angle, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to solid_with_pocket to be a `plane_angle_measure`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<solid_with_circular_pocket>(const DB& db, const LIST& params, solid_with_circular_pocket* in)
+{
+    size_t base = GenericFill(db, params, static_cast<solid_with_pocket*>(in));
+    if (params.GetSize() < 8) { throw STEP::TypeError("expected 8 arguments to solid_with_circular_pocket"); }    do { // convert the 'pocket_radius' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->pocket_radius, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to solid_with_circular_pocket to be a `positive_length_measure`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<solid_with_protrusion>(const DB& db, const LIST& params, solid_with_protrusion* in)
+{
+    size_t base = GenericFill(db, params, static_cast<modified_solid_with_placed_configuration*>(in));
+    if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to solid_with_protrusion"); }    do { // convert the 'protrusion_height' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::solid_with_protrusion, 2>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->protrusion_height, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to solid_with_protrusion to be a `positive_length_measure`")); }
+    } while (0);
+    do { // convert the 'protrusion_draft_angle' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::solid_with_protrusion, 2>::aux_is_derived[1] = true; break; }
+        try { GenericConvert(in->protrusion_draft_angle, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to solid_with_protrusion to be a `plane_angle_measure`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<solid_with_circular_protrusion>(const DB& db, const LIST& params, solid_with_circular_protrusion* in)
+{
+    size_t base = GenericFill(db, params, static_cast<solid_with_protrusion*>(in));
+    if (params.GetSize() < 7) { throw STEP::TypeError("expected 7 arguments to solid_with_circular_protrusion"); }    do { // convert the 'protrusion_radius' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->protrusion_radius, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to solid_with_circular_protrusion to be a `positive_length_measure`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<solid_with_hole>(const DB& db, const LIST& params, solid_with_hole* in)
+{
+    size_t base = GenericFill(db, params, static_cast<solid_with_depression*>(in));
+    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to solid_with_hole"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<solid_with_stepped_round_hole>(const DB& db, const LIST& params, solid_with_stepped_round_hole* in)
+{
+    size_t base = GenericFill(db, params, static_cast<solid_with_hole*>(in));
+    if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to solid_with_stepped_round_hole"); }    do { // convert the 'segments' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::solid_with_stepped_round_hole, 1>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->segments, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to solid_with_stepped_round_hole to be a `positive_integer`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<solid_with_conical_bottom_round_hole>(const DB& db, const LIST& params, solid_with_conical_bottom_round_hole* in)
+{
+    size_t base = GenericFill(db, params, static_cast<solid_with_stepped_round_hole*>(in));
+    if (params.GetSize() < 8) { throw STEP::TypeError("expected 8 arguments to solid_with_conical_bottom_round_hole"); }    do { // convert the 'semi_apex_angle' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->semi_apex_angle, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to solid_with_conical_bottom_round_hole to be a `positive_plane_angle_measure`")); }
+    } while (0);
+    do { // convert the 'tip_radius' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->tip_radius, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to solid_with_conical_bottom_round_hole to be a `non_negative_length_measure`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<solid_with_constant_radius_edge_blend>(const DB& db, const LIST& params, solid_with_constant_radius_edge_blend* in)
+{
+    size_t base = GenericFill(db, params, static_cast<edge_blended_solid*>(in));
+    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to solid_with_constant_radius_edge_blend"); }    do { // convert the 'radius' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->radius, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to solid_with_constant_radius_edge_blend to be a `positive_length_measure`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<solid_with_slot>(const DB& db, const LIST& params, solid_with_slot* in)
+{
+    size_t base = GenericFill(db, params, static_cast<solid_with_depression*>(in));
+    if (params.GetSize() < 7) { throw STEP::TypeError("expected 7 arguments to solid_with_slot"); }    do { // convert the 'slot_width' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::solid_with_slot, 2>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->slot_width, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to solid_with_slot to be a `positive_length_measure`")); }
+    } while (0);
+    do { // convert the 'closed_ends' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::solid_with_slot, 2>::aux_is_derived[1] = true; break; }
+        try { GenericConvert(in->closed_ends, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to solid_with_slot to be a `LIST [2:2] OF LOGICAL`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<solid_with_curved_slot>(const DB& db, const LIST& params, solid_with_curved_slot* in)
+{
+    size_t base = GenericFill(db, params, static_cast<solid_with_slot*>(in));
+    if (params.GetSize() < 8) { throw STEP::TypeError("expected 8 arguments to solid_with_curved_slot"); }    do { // convert the 'slot_centreline' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->slot_centreline, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to solid_with_curved_slot to be a `bounded_curve`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<solid_with_double_offset_chamfer>(const DB& db, const LIST& params, solid_with_double_offset_chamfer* in)
+{
+    size_t base = GenericFill(db, params, static_cast<solid_with_chamfered_edges*>(in));
+    if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to solid_with_double_offset_chamfer"); }    do { // convert the 'left_offset_distance' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->left_offset_distance, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to solid_with_double_offset_chamfer to be a `positive_length_measure`")); }
+    } while (0);
+    do { // convert the 'right_offset_distance' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->right_offset_distance, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to solid_with_double_offset_chamfer to be a `positive_length_measure`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<solid_with_flat_bottom_round_hole>(const DB& db, const LIST& params, solid_with_flat_bottom_round_hole* in)
+{
+    size_t base = GenericFill(db, params, static_cast<solid_with_stepped_round_hole*>(in));
+    if (params.GetSize() < 7) { throw STEP::TypeError("expected 7 arguments to solid_with_flat_bottom_round_hole"); }    do { // convert the 'fillet_radius' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->fillet_radius, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to solid_with_flat_bottom_round_hole to be a `non_negative_length_measure`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<solid_with_general_pocket>(const DB& db, const LIST& params, solid_with_general_pocket* in)
+{
+    size_t base = GenericFill(db, params, static_cast<solid_with_pocket*>(in));
+    if (params.GetSize() < 9) { throw STEP::TypeError("expected 9 arguments to solid_with_general_pocket"); }    do { // convert the 'profile' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->profile, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to solid_with_general_pocket to be a `positioned_sketch`")); }
+    } while (0);
+    do { // convert the 'reference_point' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->reference_point, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 8 to solid_with_general_pocket to be a `point`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<solid_with_general_protrusion>(const DB& db, const LIST& params, solid_with_general_protrusion* in)
+{
+    size_t base = GenericFill(db, params, static_cast<solid_with_protrusion*>(in));
+    if (params.GetSize() < 8) { throw STEP::TypeError("expected 8 arguments to solid_with_general_protrusion"); }    do { // convert the 'profile' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->profile, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to solid_with_general_protrusion to be a `positioned_sketch`")); }
+    } while (0);
+    do { // convert the 'reference_point' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->reference_point, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to solid_with_general_protrusion to be a `point`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<solid_with_groove>(const DB& db, const LIST& params, solid_with_groove* in)
+{
+    size_t base = GenericFill(db, params, static_cast<solid_with_depression*>(in));
+    if (params.GetSize() < 10) { throw STEP::TypeError("expected 10 arguments to solid_with_groove"); }    do { // convert the 'groove_radius' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->groove_radius, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to solid_with_groove to be a `positive_length_measure`")); }
+    } while (0);
+    do { // convert the 'groove_width' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->groove_width, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to solid_with_groove to be a `positive_length_measure`")); }
+    } while (0);
+    do { // convert the 'draft_angle' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->draft_angle, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to solid_with_groove to be a `plane_angle_measure`")); }
+    } while (0);
+    do { // convert the 'floor_fillet_radius' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->floor_fillet_radius, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 8 to solid_with_groove to be a `non_negative_length_measure`")); }
+    } while (0);
+    do { // convert the 'external_groove' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->external_groove, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 9 to solid_with_groove to be a `BOOLEAN`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<solid_with_incomplete_circular_pattern>(const DB& db, const LIST& params, solid_with_incomplete_circular_pattern* in)
+{
+    size_t base = GenericFill(db, params, static_cast<solid_with_circular_pattern*>(in));
+    if (params.GetSize() < 10) { throw STEP::TypeError("expected 10 arguments to solid_with_incomplete_circular_pattern"); }    do { // convert the 'omitted_instances' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->omitted_instances, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 9 to solid_with_incomplete_circular_pattern to be a `SET [1:?] OF positive_integer`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<solid_with_rectangular_pattern>(const DB& db, const LIST& params, solid_with_rectangular_pattern* in)
+{
+    size_t base = GenericFill(db, params, static_cast<solid_with_shape_element_pattern*>(in));
+    if (params.GetSize() < 9) { throw STEP::TypeError("expected 9 arguments to solid_with_rectangular_pattern"); }    do { // convert the 'row_count' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::solid_with_rectangular_pattern, 4>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->row_count, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to solid_with_rectangular_pattern to be a `positive_integer`")); }
+    } while (0);
+    do { // convert the 'column_count' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::solid_with_rectangular_pattern, 4>::aux_is_derived[1] = true; break; }
+        try { GenericConvert(in->column_count, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to solid_with_rectangular_pattern to be a `positive_integer`")); }
+    } while (0);
+    do { // convert the 'row_spacing' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::solid_with_rectangular_pattern, 4>::aux_is_derived[2] = true; break; }
+        try { GenericConvert(in->row_spacing, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to solid_with_rectangular_pattern to be a `length_measure`")); }
+    } while (0);
+    do { // convert the 'column_spacing' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::solid_with_rectangular_pattern, 4>::aux_is_derived[3] = true; break; }
+        try { GenericConvert(in->column_spacing, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 8 to solid_with_rectangular_pattern to be a `length_measure`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<solid_with_incomplete_rectangular_pattern>(const DB& db, const LIST& params, solid_with_incomplete_rectangular_pattern* in)
+{
+    size_t base = GenericFill(db, params, static_cast<solid_with_rectangular_pattern*>(in));
+    if (params.GetSize() < 9) { throw STEP::TypeError("expected 9 arguments to solid_with_incomplete_rectangular_pattern"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<solid_with_rectangular_pocket>(const DB& db, const LIST& params, solid_with_rectangular_pocket* in)
+{
+    size_t base = GenericFill(db, params, static_cast<solid_with_pocket*>(in));
+    if (params.GetSize() < 10) { throw STEP::TypeError("expected 10 arguments to solid_with_rectangular_pocket"); }    do { // convert the 'pocket_length' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->pocket_length, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to solid_with_rectangular_pocket to be a `positive_length_measure`")); }
+    } while (0);
+    do { // convert the 'pocket_width' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->pocket_width, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 8 to solid_with_rectangular_pocket to be a `positive_length_measure`")); }
+    } while (0);
+    do { // convert the 'corner_radius' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->corner_radius, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 9 to solid_with_rectangular_pocket to be a `non_negative_length_measure`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<solid_with_rectangular_protrusion>(const DB& db, const LIST& params, solid_with_rectangular_protrusion* in)
+{
+    size_t base = GenericFill(db, params, static_cast<solid_with_protrusion*>(in));
+    if (params.GetSize() < 9) { throw STEP::TypeError("expected 9 arguments to solid_with_rectangular_protrusion"); }    do { // convert the 'protrusion_length' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->protrusion_length, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to solid_with_rectangular_protrusion to be a `positive_length_measure`")); }
+    } while (0);
+    do { // convert the 'protrusion_width' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->protrusion_width, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to solid_with_rectangular_protrusion to be a `positive_length_measure`")); }
+    } while (0);
+    do { // convert the 'protrusion_corner_radius' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->protrusion_corner_radius, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 8 to solid_with_rectangular_protrusion to be a `non_negative_length_measure`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<solid_with_single_offset_chamfer>(const DB& db, const LIST& params, solid_with_single_offset_chamfer* in)
+{
+    size_t base = GenericFill(db, params, static_cast<solid_with_chamfered_edges*>(in));
+    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to solid_with_single_offset_chamfer"); }    do { // convert the 'offset_distance' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->offset_distance, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to solid_with_single_offset_chamfer to be a `positive_length_measure`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<solid_with_spherical_bottom_round_hole>(const DB& db, const LIST& params, solid_with_spherical_bottom_round_hole* in)
+{
+    size_t base = GenericFill(db, params, static_cast<solid_with_stepped_round_hole*>(in));
+    if (params.GetSize() < 7) { throw STEP::TypeError("expected 7 arguments to solid_with_spherical_bottom_round_hole"); }    do { // convert the 'sphere_radius' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->sphere_radius, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to solid_with_spherical_bottom_round_hole to be a `positive_length_measure`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<solid_with_stepped_round_hole_and_conical_transitions>(const DB& db, const LIST& params, solid_with_stepped_round_hole_and_conical_transitions* in)
+{
+    size_t base = GenericFill(db, params, static_cast<solid_with_stepped_round_hole*>(in));
+    if (params.GetSize() < 7) { throw STEP::TypeError("expected 7 arguments to solid_with_stepped_round_hole_and_conical_transitions"); }    do { // convert the 'conical_transitions' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->conical_transitions, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to solid_with_stepped_round_hole_and_conical_transitions to be a `SET [1:?] OF conical_stepped_hole_transition`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<solid_with_straight_slot>(const DB& db, const LIST& params, solid_with_straight_slot* in)
+{
+    size_t base = GenericFill(db, params, static_cast<solid_with_slot*>(in));
+    if (params.GetSize() < 8) { throw STEP::TypeError("expected 8 arguments to solid_with_straight_slot"); }    do { // convert the 'slot_length' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->slot_length, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to solid_with_straight_slot to be a `positive_length_measure`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<solid_with_tee_section_slot>(const DB& db, const LIST& params, solid_with_tee_section_slot* in)
+{
+    size_t base = GenericFill(db, params, static_cast<solid_with_slot*>(in));
+    if (params.GetSize() < 9) { throw STEP::TypeError("expected 9 arguments to solid_with_tee_section_slot"); }    do { // convert the 'tee_section_width' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->tee_section_width, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to solid_with_tee_section_slot to be a `positive_length_measure`")); }
+    } while (0);
+    do { // convert the 'collar_depth' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->collar_depth, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 8 to solid_with_tee_section_slot to be a `positive_length_measure`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<solid_with_through_depression>(const DB& db, const LIST& params, solid_with_through_depression* in)
+{
+    size_t base = GenericFill(db, params, static_cast<solid_with_depression*>(in));
+    if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to solid_with_through_depression"); }    do { // convert the 'exit_faces' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->exit_faces, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to solid_with_through_depression to be a `SET [1:?] OF face_surface`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<solid_with_trapezoidal_section_slot>(const DB& db, const LIST& params, solid_with_trapezoidal_section_slot* in)
+{
+    size_t base = GenericFill(db, params, static_cast<solid_with_slot*>(in));
+    if (params.GetSize() < 9) { throw STEP::TypeError("expected 9 arguments to solid_with_trapezoidal_section_slot"); }    do { // convert the 'draft_angle' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->draft_angle, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to solid_with_trapezoidal_section_slot to be a `plane_angle_measure`")); }
+    } while (0);
+    do { // convert the 'floor_fillet_radius' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->floor_fillet_radius, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 8 to solid_with_trapezoidal_section_slot to be a `non_negative_length_measure`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<solid_with_variable_radius_edge_blend>(const DB& db, const LIST& params, solid_with_variable_radius_edge_blend* in)
+{
+    size_t base = 0;
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to solid_with_variable_radius_edge_blend"); }    do { // convert the 'point_list' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->point_list, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to solid_with_variable_radius_edge_blend to be a `LIST [2:?] OF point`")); }
+    } while (0);
+    do { // convert the 'radius_list' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->radius_list, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to solid_with_variable_radius_edge_blend to be a `LIST [2:?] OF positive_length_measure`")); }
+    } while (0);
+    do { // convert the 'edge_function_list' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->edge_function_list, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to solid_with_variable_radius_edge_blend to be a `LIST [1:?] OF blend_radius_variation_type`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<source_for_requirement>(const DB& db, const LIST& params, source_for_requirement* in)
+{
+    size_t base = GenericFill(db, params, static_cast<group_assignment*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to source_for_requirement"); }    do { // convert the 'items' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->items, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to source_for_requirement to be a `SET [1:1] OF requirement_source_item`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<sourced_requirement>(const DB& db, const LIST& params, sourced_requirement* in)
+{
+    size_t base = GenericFill(db, params, static_cast<group_assignment*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to sourced_requirement"); }    do { // convert the 'items' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->items, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to sourced_requirement to be a `SET [1:1] OF product_definition`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<specification_definition>(const DB& db, const LIST& params, specification_definition* in)
+{
+    size_t base = GenericFill(db, params, static_cast<product_definition*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to specification_definition"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<specified_higher_usage_occurrence>(const DB& db, const LIST& params, specified_higher_usage_occurrence* in)
+{
+    size_t base = GenericFill(db, params, static_cast<assembly_component_usage*>(in));
+    if (params.GetSize() < 8) { throw STEP::TypeError("expected 8 arguments to specified_higher_usage_occurrence"); }    do { // convert the 'upper_usage' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->upper_usage, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to specified_higher_usage_occurrence to be a `assembly_component_usage`")); }
+    } while (0);
+    do { // convert the 'next_usage' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->next_usage, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to specified_higher_usage_occurrence to be a `next_assembly_usage_occurrence`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<sphere>(const DB& db, const LIST& params, sphere* in)
+{
+    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to sphere"); }    do { // convert the 'radius' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->radius, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to sphere to be a `positive_length_measure`")); }
+    } while (0);
+    do { // convert the 'centre' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->centre, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to sphere to be a `point`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<spherical_surface>(const DB& db, const LIST& params, spherical_surface* in)
+{
+    size_t base = GenericFill(db, params, static_cast<elementary_surface*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to spherical_surface"); }    do { // convert the 'radius' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->radius, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to spherical_surface to be a `positive_length_measure`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<start_request>(const DB& db, const LIST& params, start_request* in)
+{
+    size_t base = GenericFill(db, params, static_cast<action_request_assignment*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to start_request"); }    do { // convert the 'items' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->items, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to start_request to be a `SET [1:?] OF start_request_item`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<start_work>(const DB& db, const LIST& params, start_work* in)
+{
+    size_t base = GenericFill(db, params, static_cast<action_assignment*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to start_work"); }    do { // convert the 'items' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->items, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to start_work to be a `SET [1:?] OF work_item`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<straightness_tolerance>(const DB& db, const LIST& params, straightness_tolerance* in)
+{
+    size_t base = GenericFill(db, params, static_cast<geometric_tolerance*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to straightness_tolerance"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<structured_dimension_callout>(const DB& db, const LIST& params, structured_dimension_callout* in)
+{
+    size_t base = GenericFill(db, params, static_cast<draughting_callout*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to structured_dimension_callout"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<structured_text_composition>(const DB& db, const LIST& params, structured_text_composition* in)
+{
+    size_t base = GenericFill(db, params, static_cast<compound_representation_item*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to structured_text_composition"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<structured_text_representation>(const DB& db, const LIST& params, structured_text_representation* in)
+{
+    size_t base = GenericFill(db, params, static_cast<representation*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to structured_text_representation"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<subedge>(const DB& db, const LIST& params, subedge* in)
+{
+    size_t base = GenericFill(db, params, static_cast<edge*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to subedge"); }    do { // convert the 'parent_edge' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->parent_edge, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to subedge to be a `edge`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<subface>(const DB& db, const LIST& params, subface* in)
+{
+    size_t base = GenericFill(db, params, static_cast<face*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to subface"); }    do { // convert the 'parent_face' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->parent_face, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to subface to be a `face`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<supplied_part_relationship>(const DB& db, const LIST& params, supplied_part_relationship* in)
+{
+    size_t base = GenericFill(db, params, static_cast<product_definition_relationship*>(in));
+    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to supplied_part_relationship"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<surface_condition_callout>(const DB& db, const LIST& params, surface_condition_callout* in)
+{
+    size_t base = GenericFill(db, params, static_cast<draughting_callout*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to surface_condition_callout"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<swept_surface>(const DB& db, const LIST& params, swept_surface* in)
+{
+    size_t base = GenericFill(db, params, static_cast<surface*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to swept_surface"); }    do { // convert the 'swept_curve' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::swept_surface, 1>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->swept_curve, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to swept_surface to be a `curve`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<surface_of_linear_extrusion>(const DB& db, const LIST& params, surface_of_linear_extrusion* in)
+{
+    size_t base = GenericFill(db, params, static_cast<swept_surface*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to surface_of_linear_extrusion"); }    do { // convert the 'extrusion_axis' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->extrusion_axis, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to surface_of_linear_extrusion to be a `vector`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<surface_of_revolution>(const DB& db, const LIST& params, surface_of_revolution* in)
+{
+    size_t base = GenericFill(db, params, static_cast<swept_surface*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to surface_of_revolution"); }    do { // convert the 'axis_position' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->axis_position, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to surface_of_revolution to be a `axis1_placement`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<surface_patch>(const DB& db, const LIST& params, surface_patch* in)
+{
+    size_t base = GenericFill(db, params, static_cast<founded_item*>(in));
+    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to surface_patch"); }    do { // convert the 'parent_surface' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->parent_surface, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to surface_patch to be a `bounded_surface`")); }
+    } while (0);
+    do { // convert the 'u_transition' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->u_transition, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to surface_patch to be a `transition_code`")); }
+    } while (0);
+    do { // convert the 'v_transition' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->v_transition, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to surface_patch to be a `transition_code`")); }
+    } while (0);
+    do { // convert the 'u_sense' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->u_sense, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to surface_patch to be a `BOOLEAN`")); }
+    } while (0);
+    do { // convert the 'v_sense' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->v_sense, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to surface_patch to be a `BOOLEAN`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<surface_profile_tolerance>(const DB& db, const LIST& params, surface_profile_tolerance* in)
+{
+    size_t base = GenericFill(db, params, static_cast<geometric_tolerance*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to surface_profile_tolerance"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<surface_replica>(const DB& db, const LIST& params, surface_replica* in)
+{
+    size_t base = GenericFill(db, params, static_cast<surface*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to surface_replica"); }    do { // convert the 'parent_surface' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->parent_surface, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to surface_replica to be a `surface`")); }
+    } while (0);
+    do { // convert the 'transformation' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->transformation, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to surface_replica to be a `cartesian_transformation_operator_3d`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<surface_side_style>(const DB& db, const LIST& params, surface_side_style* in)
+{
+    size_t base = GenericFill(db, params, static_cast<founded_item*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to surface_side_style"); }    do { // convert the 'name' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->name, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to surface_side_style to be a `label`")); }
+    } while (0);
+    do { // convert the 'styles' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->styles, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to surface_side_style to be a `SET [1:7] OF surface_style_element_select`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<surface_style_boundary>(const DB& db, const LIST& params, surface_style_boundary* in)
+{
+    size_t base = GenericFill(db, params, static_cast<founded_item*>(in));
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to surface_style_boundary"); }    do { // convert the 'style_of_boundary' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->style_of_boundary, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to surface_style_boundary to be a `curve_or_render`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<surface_style_control_grid>(const DB& db, const LIST& params, surface_style_control_grid* in)
+{
+    size_t base = GenericFill(db, params, static_cast<founded_item*>(in));
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to surface_style_control_grid"); }    do { // convert the 'style_of_control_grid' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->style_of_control_grid, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to surface_style_control_grid to be a `curve_or_render`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<surface_style_fill_area>(const DB& db, const LIST& params, surface_style_fill_area* in)
+{
+    size_t base = GenericFill(db, params, static_cast<founded_item*>(in));
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to surface_style_fill_area"); }    do { // convert the 'fill_area' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->fill_area, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to surface_style_fill_area to be a `fill_area_style`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<surface_style_parameter_line>(const DB& db, const LIST& params, surface_style_parameter_line* in)
+{
+    size_t base = GenericFill(db, params, static_cast<founded_item*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to surface_style_parameter_line"); }    do { // convert the 'style_of_parameter_lines' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->style_of_parameter_lines, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to surface_style_parameter_line to be a `curve_or_render`")); }
+    } while (0);
+    do { // convert the 'direction_counts' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->direction_counts, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to surface_style_parameter_line to be a `SET [1:2] OF direction_count_select`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<surface_style_reflectance_ambient>(const DB& db, const LIST& params, surface_style_reflectance_ambient* in)
+{
+    size_t base = 0;
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to surface_style_reflectance_ambient"); }    do { // convert the 'ambient_reflectance' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::surface_style_reflectance_ambient, 1>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->ambient_reflectance, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to surface_style_reflectance_ambient to be a `REAL`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<surface_style_reflectance_ambient_diffuse>(const DB& db, const LIST& params, surface_style_reflectance_ambient_diffuse* in)
+{
+    size_t base = GenericFill(db, params, static_cast<surface_style_reflectance_ambient*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to surface_style_reflectance_ambient_diffuse"); }    do { // convert the 'diffuse_reflectance' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::surface_style_reflectance_ambient_diffuse, 1>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->diffuse_reflectance, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to surface_style_reflectance_ambient_diffuse to be a `REAL`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<surface_style_reflectance_ambient_diffuse_specular>(const DB& db, const LIST& params, surface_style_reflectance_ambient_diffuse_specular* in)
+{
+    size_t base = GenericFill(db, params, static_cast<surface_style_reflectance_ambient_diffuse*>(in));
+    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to surface_style_reflectance_ambient_diffuse_specular"); }    do { // convert the 'specular_reflectance' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->specular_reflectance, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to surface_style_reflectance_ambient_diffuse_specular to be a `REAL`")); }
+    } while (0);
+    do { // convert the 'specular_exponent' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->specular_exponent, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to surface_style_reflectance_ambient_diffuse_specular to be a `REAL`")); }
+    } while (0);
+    do { // convert the 'specular_colour' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->specular_colour, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to surface_style_reflectance_ambient_diffuse_specular to be a `colour`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<surface_style_rendering>(const DB& db, const LIST& params, surface_style_rendering* in)
+{
+    size_t base = 0;
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to surface_style_rendering"); }    do { // convert the 'rendering_method' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::surface_style_rendering, 2>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->rendering_method, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to surface_style_rendering to be a `shading_surface_method`")); }
+    } while (0);
+    do { // convert the 'surface_colour' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::surface_style_rendering, 2>::aux_is_derived[1] = true; break; }
+        try { GenericConvert(in->surface_colour, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to surface_style_rendering to be a `colour`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<surface_style_rendering_with_properties>(const DB& db, const LIST& params, surface_style_rendering_with_properties* in)
+{
+    size_t base = GenericFill(db, params, static_cast<surface_style_rendering*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to surface_style_rendering_with_properties"); }    do { // convert the 'properties' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->properties, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to surface_style_rendering_with_properties to be a `SET [1:2] OF rendering_properties_select`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<surface_style_segmentation_curve>(const DB& db, const LIST& params, surface_style_segmentation_curve* in)
+{
+    size_t base = GenericFill(db, params, static_cast<founded_item*>(in));
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to surface_style_segmentation_curve"); }    do { // convert the 'style_of_segmentation_curve' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->style_of_segmentation_curve, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to surface_style_segmentation_curve to be a `curve_or_render`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<surface_style_silhouette>(const DB& db, const LIST& params, surface_style_silhouette* in)
+{
+    size_t base = GenericFill(db, params, static_cast<founded_item*>(in));
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to surface_style_silhouette"); }    do { // convert the 'style_of_silhouette' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->style_of_silhouette, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to surface_style_silhouette to be a `curve_or_render`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<surface_style_usage>(const DB& db, const LIST& params, surface_style_usage* in)
+{
+    size_t base = GenericFill(db, params, static_cast<founded_item*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to surface_style_usage"); }    do { // convert the 'side' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->side, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to surface_style_usage to be a `surface_side`")); }
+    } while (0);
+    do { // convert the 'style' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->style, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to surface_style_usage to be a `surface_side_style_select`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<surface_texture_representation>(const DB& db, const LIST& params, surface_texture_representation* in)
+{
+    size_t base = GenericFill(db, params, static_cast<representation*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to surface_texture_representation"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<surfaced_open_shell>(const DB& db, const LIST& params, surfaced_open_shell* in)
+{
+    size_t base = GenericFill(db, params, static_cast<open_shell*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to surfaced_open_shell"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<swept_disk_solid>(const DB& db, const LIST& params, swept_disk_solid* in)
+{
+    size_t base = GenericFill(db, params, static_cast<solid_model*>(in));
+    if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to swept_disk_solid"); }    do { // convert the 'directrix' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->directrix, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to swept_disk_solid to be a `curve`")); }
+    } while (0);
+    do { // convert the 'radius' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->radius, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to swept_disk_solid to be a `positive_length_measure`")); }
+    } while (0);
+    do { // convert the 'inner_radius' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert(in->inner_radius, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to swept_disk_solid to be a `positive_length_measure`")); }
+    } while (0);
+    do { // convert the 'start_param' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->start_param, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to swept_disk_solid to be a `REAL`")); }
+    } while (0);
+    do { // convert the 'end_param' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->end_param, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to swept_disk_solid to be a `REAL`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<symbol>(const DB& db, const LIST& params, symbol* in)
+{
+    size_t base = GenericFill(db, params, static_cast<representation_item*>(in));
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to symbol"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<symbol_representation_map>(const DB& db, const LIST& params, symbol_representation_map* in)
+{
+    size_t base = GenericFill(db, params, static_cast<representation_map*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to symbol_representation_map"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<symbol_style>(const DB& db, const LIST& params, symbol_style* in)
+{
+    size_t base = GenericFill(db, params, static_cast<founded_item*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to symbol_style"); }    do { // convert the 'name' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->name, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to symbol_style to be a `label`")); }
+    } while (0);
+    do { // convert the 'style_of_symbol' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->style_of_symbol, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to symbol_style to be a `symbol_style_select`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<symbol_target>(const DB& db, const LIST& params, symbol_target* in)
+{
+    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to symbol_target"); }    do { // convert the 'placement' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->placement, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to symbol_target to be a `axis2_placement`")); }
+    } while (0);
+    do { // convert the 'x_scale' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->x_scale, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to symbol_target to be a `positive_ratio_measure`")); }
+    } while (0);
+    do { // convert the 'y_scale' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->y_scale, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to symbol_target to be a `positive_ratio_measure`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<symmetric_shape_aspect>(const DB& db, const LIST& params, symmetric_shape_aspect* in)
+{
+    size_t base = GenericFill(db, params, static_cast<shape_aspect*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to symmetric_shape_aspect"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<symmetry_tolerance>(const DB& db, const LIST& params, symmetry_tolerance* in)
+{
+    size_t base = GenericFill(db, params, static_cast<geometric_tolerance_with_datum_reference*>(in));
+    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to symmetry_tolerance"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<table_representation_item>(const DB& db, const LIST& params, table_representation_item* in)
+{
+    size_t base = GenericFill(db, params, static_cast<compound_representation_item*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to table_representation_item"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<tactile_appearance_representation>(const DB& db, const LIST& params, tactile_appearance_representation* in)
+{
+    size_t base = GenericFill(db, params, static_cast<representation*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to tactile_appearance_representation"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<tagged_text_format>(const DB& db, const LIST& params, tagged_text_format* in)
+{
+    size_t base = GenericFill(db, params, static_cast<representation_context*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to tagged_text_format"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<tagged_text_item>(const DB& db, const LIST& params, tagged_text_item* in)
+{
+    size_t base = GenericFill(db, params, static_cast<descriptive_representation_item*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to tagged_text_item"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<tangent>(const DB& db, const LIST& params, tangent* in)
+{
+    size_t base = GenericFill(db, params, static_cast<derived_shape_aspect*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to tangent"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<text_literal_with_associated_curves>(const DB& db, const LIST& params, text_literal_with_associated_curves* in)
+{
+    size_t base = GenericFill(db, params, static_cast<text_literal*>(in));
+    if (params.GetSize() < 7) { throw STEP::TypeError("expected 7 arguments to text_literal_with_associated_curves"); }    do { // convert the 'associated_curves' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->associated_curves, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to text_literal_with_associated_curves to be a `SET [1:?] OF curve`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<text_literal_with_blanking_box>(const DB& db, const LIST& params, text_literal_with_blanking_box* in)
+{
+    size_t base = GenericFill(db, params, static_cast<text_literal*>(in));
+    if (params.GetSize() < 7) { throw STEP::TypeError("expected 7 arguments to text_literal_with_blanking_box"); }    do { // convert the 'blanking' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->blanking, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to text_literal_with_blanking_box to be a `planar_box`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<text_literal_with_extent>(const DB& db, const LIST& params, text_literal_with_extent* in)
+{
+    size_t base = GenericFill(db, params, static_cast<text_literal*>(in));
+    if (params.GetSize() < 7) { throw STEP::TypeError("expected 7 arguments to text_literal_with_extent"); }    do { // convert the 'extent' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->extent, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to text_literal_with_extent to be a `planar_extent`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<text_string_representation>(const DB& db, const LIST& params, text_string_representation* in)
+{
+    size_t base = GenericFill(db, params, static_cast<representation*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to text_string_representation"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<text_style>(const DB& db, const LIST& params, text_style* in)
+{
+    size_t base = GenericFill(db, params, static_cast<founded_item*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to text_style"); }    do { // convert the 'name' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::text_style, 2>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->name, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to text_style to be a `label`")); }
+    } while (0);
+    do { // convert the 'character_appearance' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::text_style, 2>::aux_is_derived[1] = true; break; }
+        try { GenericConvert(in->character_appearance, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to text_style to be a `character_style_select`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<text_style_with_box_characteristics>(const DB& db, const LIST& params, text_style_with_box_characteristics* in)
+{
+    size_t base = GenericFill(db, params, static_cast<text_style*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to text_style_with_box_characteristics"); }    do { // convert the 'characteristics' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->characteristics, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to text_style_with_box_characteristics to be a `SET [1:4] OF box_characteristic_select`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<text_style_with_mirror>(const DB& db, const LIST& params, text_style_with_mirror* in)
+{
+    size_t base = GenericFill(db, params, static_cast<text_style*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to text_style_with_mirror"); }    do { // convert the 'mirror_placement' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->mirror_placement, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to text_style_with_mirror to be a `axis2_placement`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<text_style_with_spacing>(const DB& db, const LIST& params, text_style_with_spacing* in)
+{
+    size_t base = GenericFill(db, params, static_cast<text_style*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to text_style_with_spacing"); }    do { // convert the 'character_spacing' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->character_spacing, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to text_style_with_spacing to be a `character_spacing_select`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<thermal_resistance_measure_with_unit>(const DB& db, const LIST& params, thermal_resistance_measure_with_unit* in)
+{
+    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to thermal_resistance_measure_with_unit"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<thermal_resistance_unit>(const DB& db, const LIST& params, thermal_resistance_unit* in)
+{
+    size_t base = GenericFill(db, params, static_cast<derived_unit*>(in));
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to thermal_resistance_unit"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<thermodynamic_temperature_measure_with_unit>(const DB& db, const LIST& params, thermodynamic_temperature_measure_with_unit* in)
+{
+    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to thermodynamic_temperature_measure_with_unit"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<thermodynamic_temperature_unit>(const DB& db, const LIST& params, thermodynamic_temperature_unit* in)
+{
+    size_t base = GenericFill(db, params, static_cast<named_unit*>(in));
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to thermodynamic_temperature_unit"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<thickened_face_solid>(const DB& db, const LIST& params, thickened_face_solid* in)
+{
+    size_t base = GenericFill(db, params, static_cast<solid_model*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to thickened_face_solid"); }    do { // convert the 'base_element' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->base_element, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to thickened_face_solid to be a `generalized_surface_select`")); }
+    } while (0);
+    do { // convert the 'offset1' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->offset1, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to thickened_face_solid to be a `length_measure`")); }
+    } while (0);
+    do { // convert the 'offset2' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->offset2, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to thickened_face_solid to be a `length_measure`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<thickness_laminate_definition>(const DB& db, const LIST& params, thickness_laminate_definition* in)
+{
+    size_t base = GenericFill(db, params, static_cast<product_definition*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to thickness_laminate_definition"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<thickness_laminate_table>(const DB& db, const LIST& params, thickness_laminate_table* in)
+{
+    size_t base = GenericFill(db, params, static_cast<zone_structural_makeup*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to thickness_laminate_table"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<time_interval>(const DB& db, const LIST& params, time_interval* in)
+{
+    size_t base = 0;
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to time_interval"); }    do { // convert the 'id' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::time_interval, 3>::aux_is_derived[0] = true; break; }
+        try { GenericConvert(in->id, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to time_interval to be a `identifier`")); }
+    } while (0);
+    do { // convert the 'name' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::time_interval, 3>::aux_is_derived[1] = true; break; }
+        try { GenericConvert(in->name, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to time_interval to be a `label`")); }
+    } while (0);
+    do { // convert the 'description' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::StepFile::time_interval, 3>::aux_is_derived[2] = true; break; }
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert(in->description, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to time_interval to be a `text`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<time_interval_based_effectivity>(const DB& db, const LIST& params, time_interval_based_effectivity* in)
+{
+    size_t base = GenericFill(db, params, static_cast<effectivity*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to time_interval_based_effectivity"); }    do { // convert the 'effectivity_period' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->effectivity_period, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to time_interval_based_effectivity to be a `time_interval`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<time_interval_with_bounds>(const DB& db, const LIST& params, time_interval_with_bounds* in)
+{
+    size_t base = GenericFill(db, params, static_cast<time_interval*>(in));
+    if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to time_interval_with_bounds"); }    do { // convert the 'primary_bound' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert(in->primary_bound, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to time_interval_with_bounds to be a `date_time_or_event_occurrence`")); }
+    } while (0);
+    do { // convert the 'secondary_bound' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert(in->secondary_bound, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to time_interval_with_bounds to be a `date_time_or_event_occurrence`")); }
+    } while (0);
+    do { // convert the 'duration' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert(in->duration, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to time_interval_with_bounds to be a `time_measure_with_unit`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<time_measure_with_unit>(const DB& db, const LIST& params, time_measure_with_unit* in)
+{
+    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to time_measure_with_unit"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<time_unit>(const DB& db, const LIST& params, time_unit* in)
+{
+    size_t base = GenericFill(db, params, static_cast<named_unit*>(in));
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to time_unit"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<tolerance_zone>(const DB& db, const LIST& params, tolerance_zone* in)
+{
+    size_t base = GenericFill(db, params, static_cast<shape_aspect*>(in));
+    if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to tolerance_zone"); }    do { // convert the 'defining_tolerance' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->defining_tolerance, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to tolerance_zone to be a `SET [1:?] OF geometric_tolerance`")); }
+    } while (0);
+    do { // convert the 'form' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->form, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to tolerance_zone to be a `tolerance_zone_form`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<torus>(const DB& db, const LIST& params, torus* in)
+{
+    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to torus"); }    do { // convert the 'position' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->position, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to torus to be a `axis1_placement`")); }
+    } while (0);
+    do { // convert the 'major_radius' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->major_radius, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to torus to be a `positive_length_measure`")); }
+    } while (0);
+    do { // convert the 'minor_radius' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->minor_radius, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to torus to be a `positive_length_measure`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<total_runout_tolerance>(const DB& db, const LIST& params, total_runout_tolerance* in)
+{
+    size_t base = GenericFill(db, params, static_cast<geometric_tolerance_with_datum_reference*>(in));
+    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to total_runout_tolerance"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<track_blended_solid>(const DB& db, const LIST& params, track_blended_solid* in)
+{
+    size_t base = GenericFill(db, params, static_cast<edge_blended_solid*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to track_blended_solid"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<track_blended_solid_with_end_conditions>(const DB& db, const LIST& params, track_blended_solid_with_end_conditions* in)
+{
+    size_t base = GenericFill(db, params, static_cast<track_blended_solid*>(in));
+    if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to track_blended_solid_with_end_conditions"); }    do { // convert the 'end_conditions' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->end_conditions, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to track_blended_solid_with_end_conditions to be a `LIST [2:2] OF blend_end_condition_select`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<trimmed_curve>(const DB& db, const LIST& params, trimmed_curve* in)
+{
+    size_t base = GenericFill(db, params, static_cast<bounded_curve*>(in));
+    if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to trimmed_curve"); }    do { // convert the 'basis_curve' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->basis_curve, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to trimmed_curve to be a `curve`")); }
+    } while (0);
+    do { // convert the 'trim_1' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->trim_1, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to trimmed_curve to be a `SET [1:2] OF trimming_select`")); }
+    } while (0);
+    do { // convert the 'trim_2' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->trim_2, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to trimmed_curve to be a `SET [1:2] OF trimming_select`")); }
+    } while (0);
+    do { // convert the 'sense_agreement' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->sense_agreement, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to trimmed_curve to be a `BOOLEAN`")); }
+    } while (0);
+    do { // convert the 'master_representation' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->master_representation, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to trimmed_curve to be a `trimming_preference`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<two_direction_repeat_factor>(const DB& db, const LIST& params, two_direction_repeat_factor* in)
+{
+    size_t base = GenericFill(db, params, static_cast<one_direction_repeat_factor*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to two_direction_repeat_factor"); }    do { // convert the 'second_repeat_factor' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->second_repeat_factor, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to two_direction_repeat_factor to be a `vector`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<unary_generic_expression>(const DB& db, const LIST& params, unary_generic_expression* in)
+{
+    size_t base = GenericFill(db, params, static_cast<generic_expression*>(in));
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to unary_generic_expression"); }    do { // convert the 'operand' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->operand, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to unary_generic_expression to be a `generic_expression`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<unary_numeric_expression>(const DB& db, const LIST& params, unary_numeric_expression* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<uncertainty_assigned_representation>(const DB& db, const LIST& params, uncertainty_assigned_representation* in)
+{
+    size_t base = GenericFill(db, params, static_cast<representation*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to uncertainty_assigned_representation"); }    do { // convert the 'uncertainty' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->uncertainty, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to uncertainty_assigned_representation to be a `SET [1:?] OF uncertainty_measure_with_unit`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<uncertainty_measure_with_unit>(const DB& db, const LIST& params, uncertainty_measure_with_unit* in)
+{
+    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to uncertainty_measure_with_unit"); }    do { // convert the 'name' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->name, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to uncertainty_measure_with_unit to be a `label`")); }
+    } while (0);
+    do { // convert the 'description' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert(in->description, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to uncertainty_measure_with_unit to be a `text`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<uniform_curve>(const DB& db, const LIST& params, uniform_curve* in)
+{
+    size_t base = GenericFill(db, params, static_cast<b_spline_curve*>(in));
+    if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to uniform_curve"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<uniform_resource_identifier>(const DB& db, const LIST& params, uniform_resource_identifier* in)
+{
+    size_t base = GenericFill(db, params, static_cast<descriptive_representation_item*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to uniform_resource_identifier"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<uniform_surface>(const DB& db, const LIST& params, uniform_surface* in)
+{
+    size_t base = GenericFill(db, params, static_cast<b_spline_surface*>(in));
+    if (params.GetSize() < 7) { throw STEP::TypeError("expected 7 arguments to uniform_surface"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<usage_association>(const DB& db, const LIST& params, usage_association* in)
+{
+    size_t base = GenericFill(db, params, static_cast<action_method_relationship*>(in));
+    if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to usage_association"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<user_defined_curve_font>(const DB& db, const LIST& params, user_defined_curve_font* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<user_defined_marker>(const DB& db, const LIST& params, user_defined_marker* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<user_defined_terminator_symbol>(const DB& db, const LIST& params, user_defined_terminator_symbol* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<user_selected_shape_elements>(const DB& db, const LIST& params, user_selected_shape_elements* in)
+{
+    size_t base = GenericFill(db, params, static_cast<user_selected_elements*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to user_selected_shape_elements"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<value_range>(const DB& db, const LIST& params, value_range* in)
+{
+    size_t base = GenericFill(db, params, static_cast<compound_representation_item*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to value_range"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<value_representation_item>(const DB& db, const LIST& params, value_representation_item* in)
+{
+    size_t base = GenericFill(db, params, static_cast<representation_item*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to value_representation_item"); }    do { // convert the 'value_component' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->value_component, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to value_representation_item to be a `measure_value`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<variable_semantics>(const DB& db, const LIST& params, variable_semantics* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<variational_representation_item>(const DB& db, const LIST& params, variational_representation_item* in)
+{
+    size_t base = GenericFill(db, params, static_cast<representation_item*>(in));
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to variational_representation_item"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<vector>(const DB& db, const LIST& params, vector* in)
+{
+    size_t base = GenericFill(db, params, static_cast<geometric_representation_item*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to vector"); }    do { // convert the 'orientation' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->orientation, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to vector to be a `direction`")); }
+    } while (0);
+    do { // convert the 'magnitude' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->magnitude, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to vector to be a `length_measure`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<vector_style>(const DB& db, const LIST& params, vector_style* in)
+{
+    size_t base = 0;
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<velocity_measure_with_unit>(const DB& db, const LIST& params, velocity_measure_with_unit* in)
+{
+    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to velocity_measure_with_unit"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<velocity_unit>(const DB& db, const LIST& params, velocity_unit* in)
+{
+    size_t base = GenericFill(db, params, static_cast<derived_unit*>(in));
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to velocity_unit"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<vertex>(const DB& db, const LIST& params, vertex* in)
+{
+    size_t base = GenericFill(db, params, static_cast<topological_representation_item*>(in));
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to vertex"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<vertex_loop>(const DB& db, const LIST& params, vertex_loop* in)
+{
+    size_t base = GenericFill(db, params, static_cast<loop*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to vertex_loop"); }    do { // convert the 'loop_vertex' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->loop_vertex, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to vertex_loop to be a `vertex`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<vertex_point>(const DB& db, const LIST& params, vertex_point* in)
+{
+    size_t base = 0;
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to vertex_point"); }    do { // convert the 'vertex_geometry' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->vertex_geometry, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to vertex_point to be a `point`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<vertex_shell>(const DB& db, const LIST& params, vertex_shell* in)
+{
+    size_t base = GenericFill(db, params, static_cast<topological_representation_item*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to vertex_shell"); }    do { // convert the 'vertex_shell_extent' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->vertex_shell_extent, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to vertex_shell to be a `vertex_loop`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<view_volume>(const DB& db, const LIST& params, view_volume* in)
+{
+    size_t base = GenericFill(db, params, static_cast<founded_item*>(in));
+    if (params.GetSize() < 9) { throw STEP::TypeError("expected 9 arguments to view_volume"); }    do { // convert the 'projection_type' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->projection_type, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to view_volume to be a `central_or_parallel`")); }
+    } while (0);
+    do { // convert the 'projection_point' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->projection_point, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to view_volume to be a `cartesian_point`")); }
+    } while (0);
+    do { // convert the 'view_plane_distance' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->view_plane_distance, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to view_volume to be a `length_measure`")); }
+    } while (0);
+    do { // convert the 'front_plane_distance' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->front_plane_distance, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to view_volume to be a `length_measure`")); }
+    } while (0);
+    do { // convert the 'front_plane_clipping' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->front_plane_clipping, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to view_volume to be a `BOOLEAN`")); }
+    } while (0);
+    do { // convert the 'back_plane_distance' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->back_plane_distance, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to view_volume to be a `length_measure`")); }
+    } while (0);
+    do { // convert the 'back_plane_clipping' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->back_plane_clipping, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to view_volume to be a `BOOLEAN`")); }
+    } while (0);
+    do { // convert the 'view_volume_sides_clipping' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->view_volume_sides_clipping, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to view_volume to be a `BOOLEAN`")); }
+    } while (0);
+    do { // convert the 'view_window' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->view_window, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 8 to view_volume to be a `planar_box`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<visual_appearance_representation>(const DB& db, const LIST& params, visual_appearance_representation* in)
+{
+    size_t base = GenericFill(db, params, static_cast<representation*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to visual_appearance_representation"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<volume_measure_with_unit>(const DB& db, const LIST& params, volume_measure_with_unit* in)
+{
+    size_t base = GenericFill(db, params, static_cast<measure_with_unit*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to volume_measure_with_unit"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<volume_unit>(const DB& db, const LIST& params, volume_unit* in)
+{
+    size_t base = GenericFill(db, params, static_cast<derived_unit*>(in));
+    if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to volume_unit"); }	return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<week_of_year_and_day_date>(const DB& db, const LIST& params, week_of_year_and_day_date* in)
+{
+    size_t base = GenericFill(db, params, static_cast<date*>(in));
+    if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to week_of_year_and_day_date"); }    do { // convert the 'week_component' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->week_component, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to week_of_year_and_day_date to be a `week_in_year_number`")); }
+    } while (0);
+    do { // convert the 'day_component' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        if (dynamic_cast<const UNSET*>(&*arg)) break;
+        try { GenericConvert(in->day_component, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to week_of_year_and_day_date to be a `day_in_week_number`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<wire_shell>(const DB& db, const LIST& params, wire_shell* in)
+{
+    size_t base = GenericFill(db, params, static_cast<topological_representation_item*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to wire_shell"); }    do { // convert the 'wire_shell_extent' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->wire_shell_extent, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to wire_shell to be a `SET [1:?] OF loop`")); }
+    } while (0);
+    return base;
+}
+// -----------------------------------------------------------------------------------------------------------
+template <> size_t GenericFill<year_month>(const DB& db, const LIST& params, year_month* in)
+{
+    size_t base = GenericFill(db, params, static_cast<date*>(in));
+    if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to year_month"); }    do { // convert the 'month_component' argument
+        std::shared_ptr<const DataType> arg = params[base++];
+        try { GenericConvert(in->month_component, arg, db); break; }
+        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to year_month to be a `month_in_year_number`")); }
+    } while (0);
+    return base;
+}
+
+}
+}

code/Importer/StepFile/StepFileImporter.cpp

@@ -0,0 +1,114 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2018, assimp team
+
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+#ifndef ASSIMP_BUILD_NO_STEPFILE_IMPORTER
+
+#include "StepFileImporter.h"
+#include "../../Importer/STEPParser/STEPFileReader.h"
+#include <assimp/importerdesc.h>
+#include <assimp/DefaultIOSystem.h>
+
+namespace Assimp {
+namespace StepFile {
+
+using namespace STEP;
+
+static const aiImporterDesc desc = { "StepFile Importer",
+                                "",
+                                "",
+                                "",
+                                0,
+                                0,
+                                0,
+                                0,
+                                0,
+                                "stp" };
+
+StepFileImporter::StepFileImporter()
+: BaseImporter() {
+
+}
+
+StepFileImporter::~StepFileImporter() {
+
+}
+
+bool StepFileImporter::CanRead(const std::string& file, IOSystem* pIOHandler, bool checkSig) const {
+    const std::string &extension = GetExtension(file);
+    if ( extension == "stp" || extension == "step" ) {
+        return true;
+    } else if ((!extension.length() || checkSig) && pIOHandler) {
+        const char* tokens[] = { "ISO-10303-21" };
+        const bool found(SearchFileHeaderForToken(pIOHandler, file, tokens, 1));
+        return found;
+    }
+
+    return false;
+}
+
+const aiImporterDesc *StepFileImporter::GetInfo() const {
+    return &desc;
+}
+
+static const std::string mode = "rb";
+static const std::string StepFileSchema = "CONFIG_CONTROL_DESIGN";
+
+void StepFileImporter::InternReadFile(const std::string &file, aiScene* pScene, IOSystem* pIOHandler) {
+    // Read file into memory
+    std::shared_ptr<IOStream> fileStream(pIOHandler->Open(file, mode));
+    if (!fileStream.get()) {
+        throw DeadlyImportError("Failed to open file " + file + ".");
+    }
+
+    std::unique_ptr<STEP::DB> db(STEP::ReadFileHeader(fileStream));
+    const STEP::HeaderInfo& head = static_cast<const STEP::DB&>(*db).GetHeader();
+    if (!head.fileSchema.size() || head.fileSchema != StepFileSchema) {
+        DeadlyImportError("Unrecognized file schema: " + head.fileSchema);
+    }
+}
+
+} // Namespace StepFile
+} // Namespace Assimp
+
+#endif // ASSIMP_BUILD_NO_STEPFILE_IMPORTER
+

code/Importer/StepFile/StepFileImporter.h

@@ -0,0 +1,69 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2018, assimp team
+
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+#pragma once
+
+#ifndef ASSIMP_BUILD_NO_STEPFILE_IMPORTER
+
+#include <assimp/BaseImporter.h>
+
+namespace Assimp {
+namespace StepFile {
+
+class StepFileImporter : public BaseImporter {
+public:
+    StepFileImporter();
+    ~StepFileImporter();
+    bool CanRead(const std::string& pFile, IOSystem* pIOHandler, bool checkSig) const override;
+    const aiImporterDesc* GetInfo() const override;
+
+protected:
+    void InternReadFile( const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler ) override;
+
+private:
+};
+
+} // Namespace StepFile
+} // Namespace Assimp
+
+#endif // ASSIMP_BUILD_NO_STEPFILE_IMPORTER

code/Importer/StepFile/StepReaderGen.h

@@ -0,0 +1,7288 @@
+/*
+Open Asset Import Library (ASSIMP)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2018, ASSIMP Development Team
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms, 
+with or without modification, are permitted provided that the 
+following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the ASSIMP team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the ASSIMP Development Team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+/** MACHINE-GENERATED by scripts/ICFImporter/CppGenerator.py */
+
+#ifndef INCLUDED_STEPFILE_READER_GEN_H
+#define INCLUDED_STEPFILE_READER_GEN_H
+
+#include "code/STEPFile.h"
+
+namespace Assimp {
+namespace StepFile {
+	using namespace STEP;
+	using namespace STEP::EXPRESS;
+	
+	
+	struct NotImplemented : public ObjectHelper<NotImplemented,0> {
+		
+	};
+	
+
+	// ******************************************************************************
+	// StepFile Custom data types
+	// ******************************************************************************
+
+
+    // C++ wrapper type for absorbed_dose_measure
+    typedef REAL absorbed_dose_measure;
+    // C++ wrapper type for acceleration_measure
+    typedef REAL acceleration_measure;
+    // C++ wrapper type for action_items
+    typedef SELECT action_items;
+    // C++ wrapper type for action_method_items
+    typedef SELECT action_method_items;
+    // C++ wrapper type for action_request_item
+    typedef SELECT action_request_item;
+    // C++ wrapper type for ahead_or_behind
+    typedef ENUMERATION ahead_or_behind;
+    // C++ wrapper type for amount_of_substance_measure
+    typedef REAL amount_of_substance_measure;
+    // C++ wrapper type for angle_direction_reference_select
+    typedef SELECT angle_direction_reference_select;
+    // C++ wrapper type for angle_direction_reference_with_a2p3d_select
+    typedef SELECT angle_direction_reference_with_a2p3d_select;
+    // C++ wrapper type for angle_relator
+    typedef ENUMERATION angle_relator;
+    // C++ wrapper type for annotation_plane_element
+    typedef SELECT annotation_plane_element;
+    // C++ wrapper type for annotation_representation_select
+    typedef SELECT annotation_representation_select;
+    // C++ wrapper type for annotation_symbol_occurrence_item
+    typedef SELECT annotation_symbol_occurrence_item;
+    // C++ wrapper type for annotation_text_occurrence_item
+    typedef SELECT annotation_text_occurrence_item;
+    // C++ wrapper type for approval_item
+    typedef SELECT approval_item;
+    // C++ wrapper type for approved_item
+    typedef SELECT approved_item;
+    // C++ wrapper type for area_measure
+    typedef REAL area_measure;
+    // C++ wrapper type for area_or_view
+    typedef SELECT area_or_view;
+    // C++ wrapper type for attribute_classification_item
+    typedef SELECT attribute_classification_item;
+    // C++ wrapper type for attribute_language_item
+    typedef SELECT attribute_language_item;
+    // C++ wrapper type for attribute_type
+    typedef SELECT attribute_type;
+    // C++ wrapper type for axis2_placement
+    typedef SELECT axis2_placement;
+    // C++ wrapper type for b_spline_curve_form
+    typedef ENUMERATION b_spline_curve_form;
+    // C++ wrapper type for b_spline_surface_form
+    typedef ENUMERATION b_spline_surface_form;
+    // C++ wrapper type for base_solid_select
+    typedef SELECT base_solid_select;
+    // C++ wrapper type for blend_end_condition_select
+    typedef SELECT blend_end_condition_select;
+    // C++ wrapper type for blend_radius_variation_type
+    typedef ENUMERATION blend_radius_variation_type;
+    // C++ wrapper type for boolean_operand
+    typedef SELECT boolean_operand;
+    // C++ wrapper type for boolean_operator
+    typedef ENUMERATION boolean_operator;
+    // C++ wrapper type for box_characteristic_select
+    typedef SELECT box_characteristic_select;
+    // C++ wrapper type for box_height
+    typedef REAL box_height;
+    // C++ wrapper type for box_rotate_angle
+    typedef REAL box_rotate_angle;
+    // C++ wrapper type for box_slant_angle
+    typedef REAL box_slant_angle;
+    // C++ wrapper type for box_width
+    typedef REAL box_width;
+    // C++ wrapper type for camera_model_d3_multi_clipping_interection_select
+    typedef SELECT camera_model_d3_multi_clipping_interection_select;
+    // C++ wrapper type for camera_model_d3_multi_clipping_union_select
+    typedef SELECT camera_model_d3_multi_clipping_union_select;
+    // C++ wrapper type for capacitance_measure
+    typedef REAL capacitance_measure;
+    // C++ wrapper type for category_usage_item
+    typedef SELECT category_usage_item;
+    // C++ wrapper type for cc_classified_item
+    typedef SELECT cc_classified_item;
+    // C++ wrapper type for cc_person_organization_item
+    typedef SELECT cc_person_organization_item;
+    // C++ wrapper type for cc_specified_item
+    typedef SELECT cc_specified_item;
+    // C++ wrapper type for celsius_temperature_measure
+    typedef REAL celsius_temperature_measure;
+    // C++ wrapper type for central_or_parallel
+    typedef ENUMERATION central_or_parallel;
+    // C++ wrapper type for certification_item
+    typedef SELECT certification_item;
+    // C++ wrapper type for certified_item
+    typedef SELECT certified_item;
+    // C++ wrapper type for change_request_item
+    typedef SELECT change_request_item;
+    // C++ wrapper type for character_spacing_select
+    typedef SELECT character_spacing_select;
+    // C++ wrapper type for character_style_select
+    typedef SELECT character_style_select;
+    // C++ wrapper type for characterized_action_definition
+    typedef SELECT characterized_action_definition;
+    // C++ wrapper type for characterized_definition
+    typedef SELECT characterized_definition;
+    // C++ wrapper type for characterized_material_property
+    typedef SELECT characterized_material_property;
+    // C++ wrapper type for characterized_product_composition_value
+    typedef SELECT characterized_product_composition_value;
+    // C++ wrapper type for characterized_product_definition
+    typedef SELECT characterized_product_definition;
+    // C++ wrapper type for class_usage_effectivity_context_item
+    typedef SELECT class_usage_effectivity_context_item;
+    // C++ wrapper type for classification_item
+    typedef SELECT classification_item;
+    // C++ wrapper type for classified_item
+    typedef SELECT classified_item;
+    // C++ wrapper type for compound_item_definition
+    typedef SELECT compound_item_definition;
+    // C++ wrapper type for conductance_measure
+    typedef REAL conductance_measure;
+    // C++ wrapper type for configuration_design_item
+    typedef SELECT configuration_design_item;
+    // C++ wrapper type for configured_effectivity_context_item
+    typedef SELECT configured_effectivity_context_item;
+    // C++ wrapper type for configured_effectivity_item
+    typedef SELECT configured_effectivity_item;
+    // C++ wrapper type for constructive_geometry_representation_or_shape_represenation
+    typedef SELECT constructive_geometry_representation_or_shape_represenation;
+    // C++ wrapper type for context_dependent_measure
+    typedef REAL context_dependent_measure;
+    // C++ wrapper type for contract_item
+    typedef SELECT contract_item;
+    // C++ wrapper type for contracted_item
+    typedef SELECT contracted_item;
+    // C++ wrapper type for count_measure
+    typedef NUMBER count_measure;
+    // C++ wrapper type for csg_primitive
+    typedef SELECT csg_primitive;
+    // C++ wrapper type for csg_select
+    typedef SELECT csg_select;
+    // C++ wrapper type for curve_font_or_scaled_curve_font_select
+    typedef SELECT curve_font_or_scaled_curve_font_select;
+    // C++ wrapper type for curve_on_surface
+    typedef SELECT curve_on_surface;
+    // C++ wrapper type for curve_or_annotation_curve_occurrence
+    typedef SELECT curve_or_annotation_curve_occurrence;
+    // C++ wrapper type for curve_or_render
+    typedef SELECT curve_or_render;
+    // C++ wrapper type for curve_style_font_select
+    typedef SELECT curve_style_font_select;
+    // C++ wrapper type for date_and_time_item
+    typedef SELECT date_and_time_item;
+    // C++ wrapper type for date_item
+    typedef SELECT date_item;
+    // C++ wrapper type for date_time_item
+    typedef SELECT date_time_item;
+    // C++ wrapper type for date_time_or_event_occurrence
+    typedef SELECT date_time_or_event_occurrence;
+    // C++ wrapper type for date_time_select
+    typedef SELECT date_time_select;
+    // C++ wrapper type for day_in_month_number
+    typedef INTEGER day_in_month_number;
+    // C++ wrapper type for day_in_week_number
+    typedef INTEGER day_in_week_number;
+    // C++ wrapper type for day_in_year_number
+    typedef INTEGER day_in_year_number;
+    // C++ wrapper type for defined_symbol_select
+    typedef SELECT defined_symbol_select;
+    // C++ wrapper type for derived_property_select
+    typedef SELECT derived_property_select;
+    // C++ wrapper type for description_attribute_select
+    typedef SELECT description_attribute_select;
+    // C++ wrapper type for descriptive_measure
+    typedef STRING descriptive_measure;
+    // C++ wrapper type for dimension_count
+    typedef INTEGER dimension_count;
+    // C++ wrapper type for dimension_extent_usage
+    typedef ENUMERATION dimension_extent_usage;
+    // C++ wrapper type for dimensional_characteristic
+    typedef SELECT dimensional_characteristic;
+    // C++ wrapper type for direction_count_select
+    typedef SELECT direction_count_select;
+    // C++ wrapper type for document_identifier_assigned_item
+    typedef SELECT document_identifier_assigned_item;
+    // C++ wrapper type for document_reference_item
+    typedef SELECT document_reference_item;
+    // C++ wrapper type for dose_equivalent_measure
+    typedef REAL dose_equivalent_measure;
+    // C++ wrapper type for draughting_callout_element
+    typedef SELECT draughting_callout_element;
+    // C++ wrapper type for draughting_model_item_association_select
+    typedef SELECT draughting_model_item_association_select;
+    // C++ wrapper type for draughting_model_item_select
+    typedef SELECT draughting_model_item_select;
+    // C++ wrapper type for draughting_titled_item
+    typedef SELECT draughting_titled_item;
+    // C++ wrapper type for effectivity_item
+    typedef SELECT effectivity_item;
+    // C++ wrapper type for electric_charge_measure
+    typedef REAL electric_charge_measure;
+    // C++ wrapper type for electric_current_measure
+    typedef REAL electric_current_measure;
+    // C++ wrapper type for electric_potential_measure
+    typedef REAL electric_potential_measure;
+    // C++ wrapper type for energy_measure
+    typedef REAL energy_measure;
+    // C++ wrapper type for event_occurrence_item
+    typedef SELECT event_occurrence_item;
+    // C++ wrapper type for external_identification_item
+    typedef SELECT external_identification_item;
+    // C++ wrapper type for fill_area_style_tile_shape_select
+    typedef SELECT fill_area_style_tile_shape_select;
+    // C++ wrapper type for fill_style_select
+    typedef SELECT fill_style_select;
+    // C++ wrapper type for font_select
+    typedef SELECT font_select;
+    // C++ wrapper type for force_measure
+    typedef REAL force_measure;
+    // C++ wrapper type for founded_item_select
+    typedef SELECT founded_item_select;
+    // C++ wrapper type for frequency_measure
+    typedef REAL frequency_measure;
+    // C++ wrapper type for generalized_surface_select
+    typedef SELECT generalized_surface_select;
+    // C++ wrapper type for geometric_item_specific_usage_select
+    typedef SELECT geometric_item_specific_usage_select;
+    // C++ wrapper type for geometric_set_select
+    typedef SELECT geometric_set_select;
+    // C++ wrapper type for groupable_item
+    typedef SELECT groupable_item;
+    // C++ wrapper type for hour_in_day
+    typedef INTEGER hour_in_day;
+    // C++ wrapper type for id_attribute_select
+    typedef SELECT id_attribute_select;
+    // C++ wrapper type for identification_item
+    typedef SELECT identification_item;
+    // C++ wrapper type for identifier
+    typedef STRING identifier;
+    // C++ wrapper type for illuminance_measure
+    typedef REAL illuminance_measure;
+    // C++ wrapper type for inductance_measure
+    typedef REAL inductance_measure;
+    // C++ wrapper type for instance_usage_context_select
+    typedef SELECT instance_usage_context_select;
+    // C++ wrapper type for invisibility_context
+    typedef SELECT invisibility_context;
+    // C++ wrapper type for invisible_item
+    typedef SELECT invisible_item;
+    // C++ wrapper type for ir_usage_item
+    typedef SELECT ir_usage_item;
+    // C++ wrapper type for knot_type
+    typedef ENUMERATION knot_type;
+    // C++ wrapper type for label
+    typedef STRING label;
+    // C++ wrapper type for layered_item
+    typedef SELECT layered_item;
+    // C++ wrapper type for length_measure
+    typedef REAL length_measure;
+    // C++ wrapper type for limit_condition
+    typedef ENUMERATION limit_condition;
+    // C++ wrapper type for list_of_reversible_topology_item
+    typedef ListOf< SELECT, 0, 0 > list_of_reversible_topology_item;
+    // C++ wrapper type for luminous_flux_measure
+    typedef REAL luminous_flux_measure;
+    // C++ wrapper type for luminous_intensity_measure
+    typedef REAL luminous_intensity_measure;
+    // C++ wrapper type for magnetic_flux_density_measure
+    typedef REAL magnetic_flux_density_measure;
+    // C++ wrapper type for magnetic_flux_measure
+    typedef REAL magnetic_flux_measure;
+    // C++ wrapper type for marker_select
+    typedef SELECT marker_select;
+    // C++ wrapper type for marker_type
+    typedef ENUMERATION marker_type;
+    // C++ wrapper type for mass_measure
+    typedef REAL mass_measure;
+    // C++ wrapper type for measure_value
+    typedef SELECT measure_value;
+    // C++ wrapper type for mechanical_design_and_draughting_relationship_select
+    typedef SELECT mechanical_design_and_draughting_relationship_select;
+    // C++ wrapper type for mechanical_design_geometric_presentation_area_items
+    typedef SELECT mechanical_design_geometric_presentation_area_items;
+    // C++ wrapper type for mechanical_design_geometric_presentation_representation_items
+    typedef SELECT mechanical_design_geometric_presentation_representation_items;
+    // C++ wrapper type for message
+    typedef STRING message;
+    // C++ wrapper type for minute_in_hour
+    typedef INTEGER minute_in_hour;
+    // C++ wrapper type for month_in_year_number
+    typedef INTEGER month_in_year_number;
+    // C++ wrapper type for multi_language_attribute_item
+    typedef SELECT multi_language_attribute_item;
+    // C++ wrapper type for name_attribute_select
+    typedef SELECT name_attribute_select;
+    // C++ wrapper type for name_item
+    typedef SELECT name_item;
+    // C++ wrapper type for non_negative_length_measure
+    typedef REAL non_negative_length_measure;
+    // C++ wrapper type for nonnegative_integer
+    typedef INTEGER nonnegative_integer;
+    // C++ wrapper type for null_style
+    typedef ENUMERATION null_style;
+    // C++ wrapper type for numeric_measure
+    typedef NUMBER numeric_measure;
+    // C++ wrapper type for organization_item
+    typedef SELECT organization_item;
+    // C++ wrapper type for orientation_basis_select
+    typedef SELECT orientation_basis_select;
+    // C++ wrapper type for parameter_value
+    typedef REAL parameter_value;
+    // C++ wrapper type for pcurve_or_surface
+    typedef SELECT pcurve_or_surface;
+    // C++ wrapper type for person_and_organization_item
+    typedef SELECT person_and_organization_item;
+    // C++ wrapper type for person_organization_select
+    typedef SELECT person_organization_select;
+    // C++ wrapper type for picture_representation_item_select
+    typedef SELECT picture_representation_item_select;
+    // C++ wrapper type for plane_angle_measure
+    typedef REAL plane_angle_measure;
+    // C++ wrapper type for plane_or_planar_box
+    typedef SELECT plane_or_planar_box;
+    // C++ wrapper type for point_and_vector_member
+    typedef SELECT point_and_vector_member;
+    // C++ wrapper type for point_and_vector_members
+    typedef ListOf< SELECT, 2, 3 > point_and_vector_members;
+    // C++ wrapper type for positive_integer
+    typedef INTEGER positive_integer;
+    // C++ wrapper type for positive_length_measure
+    typedef REAL positive_length_measure;
+    // C++ wrapper type for positive_plane_angle_measure
+    typedef REAL positive_plane_angle_measure;
+    // C++ wrapper type for positive_ratio_measure
+    typedef REAL positive_ratio_measure;
+    // C++ wrapper type for power_measure
+    typedef REAL power_measure;
+    // C++ wrapper type for preferred_surface_curve_representation
+    typedef ENUMERATION preferred_surface_curve_representation;
+    // C++ wrapper type for presentable_text
+    typedef STRING presentable_text;
+    // C++ wrapper type for presentation_representation_select
+    typedef SELECT presentation_representation_select;
+    // C++ wrapper type for presentation_size_assignment_select
+    typedef SELECT presentation_size_assignment_select;
+    // C++ wrapper type for presentation_style_select
+    typedef SELECT presentation_style_select;
+    // C++ wrapper type for presented_item_select
+    typedef SELECT presented_item_select;
+    // C++ wrapper type for pressure_measure
+    typedef REAL pressure_measure;
+    // C++ wrapper type for product_definition_or_assembly_relationship
+    typedef SELECT product_definition_or_assembly_relationship;
+    // C++ wrapper type for product_definition_or_breakdown_element_usage
+    typedef SELECT product_definition_or_breakdown_element_usage;
+    // C++ wrapper type for product_definition_or_product_definition_relationship
+    typedef SELECT product_definition_or_product_definition_relationship;
+    // C++ wrapper type for product_or_formation_or_definition
+    typedef SELECT product_or_formation_or_definition;
+    // C++ wrapper type for project_item
+    typedef SELECT project_item;
+    // C++ wrapper type for radioactivity_measure
+    typedef REAL radioactivity_measure;
+    // C++ wrapper type for ratio_measure
+    typedef REAL ratio_measure;
+    // C++ wrapper type for rendering_properties_select
+    typedef SELECT rendering_properties_select;
+    // C++ wrapper type for represented_definition
+    typedef SELECT represented_definition;
+    // C++ wrapper type for requirement_assigned_item
+    typedef SELECT requirement_assigned_item;
+    // C++ wrapper type for requirement_satisfaction_item
+    typedef SELECT requirement_satisfaction_item;
+    // C++ wrapper type for requirement_source_item
+    typedef SELECT requirement_source_item;
+    // C++ wrapper type for resistance_measure
+    typedef REAL resistance_measure;
+    // C++ wrapper type for reversible_topology
+    typedef SELECT reversible_topology;
+    // C++ wrapper type for reversible_topology_item
+    typedef SELECT reversible_topology_item;
+    // C++ wrapper type for role_select
+    typedef SELECT role_select;
+    // C++ wrapper type for rule_superseded_item
+    typedef SELECT rule_superseded_item;
+    // C++ wrapper type for second_in_minute
+    typedef REAL second_in_minute;
+    // C++ wrapper type for security_classification_item
+    typedef SELECT security_classification_item;
+    // C++ wrapper type for set_of_reversible_topology_item
+    typedef ListOf< SELECT, 0, 0 > set_of_reversible_topology_item;
+    // C++ wrapper type for shading_curve_method
+    typedef ENUMERATION shading_curve_method;
+    // C++ wrapper type for shading_surface_method
+    typedef ENUMERATION shading_surface_method;
+    // C++ wrapper type for shape_definition
+    typedef SELECT shape_definition;
+    // C++ wrapper type for shell
+    typedef SELECT shell;
+    // C++ wrapper type for si_prefix
+    typedef ENUMERATION si_prefix;
+    // C++ wrapper type for si_unit_name
+    typedef ENUMERATION si_unit_name;
+    // C++ wrapper type for size_select
+    typedef SELECT size_select;
+    // C++ wrapper type for sketch_basis_select
+    typedef SELECT sketch_basis_select;
+    // C++ wrapper type for solid_angle_measure
+    typedef REAL solid_angle_measure;
+    // C++ wrapper type for source
+    typedef ENUMERATION source;
+    // C++ wrapper type for source_item
+    typedef SELECT source_item;
+    // C++ wrapper type for start_request_item
+    typedef SELECT start_request_item;
+    // C++ wrapper type for string_representation_item_select
+    typedef SELECT string_representation_item_select;
+    // C++ wrapper type for style_context_select
+    typedef SELECT style_context_select;
+    // C++ wrapper type for surface_side
+    typedef ENUMERATION surface_side;
+    // C++ wrapper type for surface_side_style_select
+    typedef SELECT surface_side_style_select;
+    // C++ wrapper type for surface_style_element_select
+    typedef SELECT surface_style_element_select;
+    // C++ wrapper type for symbol_style_select
+    typedef SELECT symbol_style_select;
+    // C++ wrapper type for text
+    typedef STRING text;
+    // C++ wrapper type for text_alignment
+    typedef STRING text_alignment;
+    // C++ wrapper type for text_delineation
+    typedef STRING text_delineation;
+    // C++ wrapper type for text_or_character
+    typedef SELECT text_or_character;
+    // C++ wrapper type for text_path
+    typedef ENUMERATION text_path;
+    // C++ wrapper type for text_string_representation_item
+    typedef SELECT text_string_representation_item;
+    // C++ wrapper type for thermodynamic_temperature_measure
+    typedef REAL thermodynamic_temperature_measure;
+    // C++ wrapper type for time_interval_item
+    typedef SELECT time_interval_item;
+    // C++ wrapper type for time_measure
+    typedef REAL time_measure;
+    // C++ wrapper type for tolerance_method_definition
+    typedef SELECT tolerance_method_definition;
+    // C++ wrapper type for transformation
+    typedef SELECT transformation;
+    // C++ wrapper type for transition_code
+    typedef ENUMERATION transition_code;
+    // C++ wrapper type for trim_condition_select
+    typedef SELECT trim_condition_select;
+    // C++ wrapper type for trim_intent
+    typedef ENUMERATION trim_intent;
+    // C++ wrapper type for trimming_preference
+    typedef ENUMERATION trimming_preference;
+    // C++ wrapper type for trimming_select
+    typedef SELECT trimming_select;
+    // C++ wrapper type for u_direction_count
+    typedef INTEGER u_direction_count;
+    // C++ wrapper type for unit
+    typedef SELECT unit;
+    // C++ wrapper type for v_direction_count
+    typedef INTEGER v_direction_count;
+    // C++ wrapper type for value_qualifier
+    typedef SELECT value_qualifier;
+    // C++ wrapper type for vector_or_direction
+    typedef SELECT vector_or_direction;
+    // C++ wrapper type for velocity_measure
+    typedef REAL velocity_measure;
+    // C++ wrapper type for volume_measure
+    typedef REAL volume_measure;
+    // C++ wrapper type for week_in_year_number
+    typedef INTEGER week_in_year_number;
+    // C++ wrapper type for work_item
+    typedef SELECT work_item;
+    // C++ wrapper type for year_number
+    typedef INTEGER year_number;
+
+
+	// ******************************************************************************
+	// StepFile Entities
+	// ******************************************************************************
+
+	struct measure_with_unit;
+	struct absorbed_dose_measure_with_unit;
+	struct derived_unit;
+	struct absorbed_dose_unit;
+	struct abstract_variable;
+	struct acceleration_measure_with_unit;
+	struct acceleration_unit;
+	struct action;
+	struct action_assignment;
+	typedef NotImplemented action_directive; // (not currently used by Assimp)
+	struct action_method;
+	struct action_method_assignment;
+	struct action_method_relationship;
+	typedef NotImplemented action_method_role; // (not currently used by Assimp)
+	typedef NotImplemented action_property; // (not currently used by Assimp)
+	typedef NotImplemented action_property_representation; // (not currently used by Assimp)
+	typedef NotImplemented action_relationship; // (not currently used by Assimp)
+	struct action_request_assignment;
+	typedef NotImplemented action_request_solution; // (not currently used by Assimp)
+	typedef NotImplemented action_request_status; // (not currently used by Assimp)
+	typedef NotImplemented action_status; // (not currently used by Assimp)
+	struct address;
+	struct representation;
+	struct shape_representation;
+	struct advanced_brep_shape_representation;
+	struct face_surface;
+	struct advanced_face;
+	typedef NotImplemented alternate_product_relationship; // (not currently used by Assimp)
+	struct amount_of_substance_measure_with_unit;
+	struct named_unit;
+	struct amount_of_substance_unit;
+	struct angle_direction_reference;
+	struct representation_item;
+	struct geometric_representation_item;
+	struct draughting_callout;
+	struct dimension_curve_directed_callout;
+	struct angular_dimension;
+	struct shape_aspect_relationship;
+	struct dimensional_location;
+	struct angular_location;
+	struct dimensional_size;
+	struct angular_size;
+	struct geometric_tolerance;
+	struct geometric_tolerance_with_datum_reference;
+	struct angularity_tolerance;
+	struct styled_item;
+	struct annotation_occurrence;
+	struct annotation_curve_occurrence;
+	struct annotation_fill_area;
+	struct annotation_fill_area_occurrence;
+	struct annotation_occurrence_relationship;
+	struct annotation_occurrence_associativity;
+	struct annotation_plane;
+	struct annotation_symbol_occurrence;
+	struct annotation_subfigure_occurrence;
+	struct mapped_item;
+	struct annotation_symbol;
+	struct annotation_text;
+	struct annotation_text_character;
+	struct annotation_text_occurrence;
+	struct shape_aspect;
+	struct derived_shape_aspect;
+	struct apex;
+	typedef NotImplemented application_context; // (not currently used by Assimp)
+	struct application_context_element;
+	typedef NotImplemented application_protocol_definition; // (not currently used by Assimp)
+	struct applied_action_assignment;
+	struct applied_action_method_assignment;
+	struct applied_action_request_assignment;
+	struct approval_assignment;
+	struct applied_approval_assignment;
+	struct attribute_classification_assignment;
+	struct applied_attribute_classification_assignment;
+	struct certification_assignment;
+	struct applied_certification_assignment;
+	struct classification_assignment;
+	struct applied_classification_assignment;
+	struct contract_assignment;
+	struct applied_contract_assignment;
+	struct date_and_time_assignment;
+	struct applied_date_and_time_assignment;
+	struct date_assignment;
+	struct applied_date_assignment;
+	struct document_reference;
+	struct applied_document_reference;
+	struct document_usage_constraint_assignment;
+	struct applied_document_usage_constraint_assignment;
+	struct effectivity_assignment;
+	struct applied_effectivity_assignment;
+	struct event_occurrence_assignment;
+	struct applied_event_occurrence_assignment;
+	struct identification_assignment;
+	struct external_identification_assignment;
+	struct applied_external_identification_assignment;
+	struct group_assignment;
+	struct applied_group_assignment;
+	struct applied_identification_assignment;
+	struct name_assignment;
+	struct applied_name_assignment;
+	struct organization_assignment;
+	struct applied_organization_assignment;
+	struct organizational_project_assignment;
+	struct applied_organizational_project_assignment;
+	struct person_and_organization_assignment;
+	struct applied_person_and_organization_assignment;
+	struct presented_item;
+	struct applied_presented_item;
+	struct security_classification_assignment;
+	struct applied_security_classification_assignment;
+	struct time_interval_assignment;
+	struct applied_time_interval_assignment;
+	struct applied_usage_right;
+	typedef NotImplemented approval; // (not currently used by Assimp)
+	typedef NotImplemented approval_date_time; // (not currently used by Assimp)
+	typedef NotImplemented approval_person_organization; // (not currently used by Assimp)
+	typedef NotImplemented approval_relationship; // (not currently used by Assimp)
+	typedef NotImplemented approval_role; // (not currently used by Assimp)
+	typedef NotImplemented approval_status; // (not currently used by Assimp)
+	struct area_in_set;
+	struct area_measure_with_unit;
+	struct area_unit;
+	struct product_definition_relationship;
+	struct product_definition_usage;
+	struct assembly_component_usage;
+	typedef NotImplemented assembly_component_usage_substitute; // (not currently used by Assimp)
+	struct assigned_requirement;
+	struct compound_representation_item;
+	struct atomic_formula;
+	struct attribute_assertion;
+	struct attribute_language_assignment;
+	struct attribute_value_assignment;
+	typedef NotImplemented attribute_value_role; // (not currently used by Assimp)
+	struct auxiliary_geometric_representation_item;
+	struct placement;
+	struct axis1_placement;
+	struct axis2_placement_2d;
+	struct axis2_placement_3d;
+	struct curve;
+	struct bounded_curve;
+	struct b_spline_curve;
+	struct b_spline_curve_with_knots;
+	struct surface;
+	struct bounded_surface;
+	struct b_spline_surface;
+	struct b_spline_surface_with_knots;
+	struct product_definition;
+	struct rule_software_definition;
+	struct rule_definition;
+	struct back_chaining_rule;
+	struct back_chaining_rule_body;
+	struct colour;
+	struct background_colour;
+	struct beveled_sheet_representation;
+	struct bezier_curve;
+	struct bezier_surface;
+	struct generic_expression;
+	struct binary_generic_expression;
+	struct binary_numeric_expression;
+	struct binary_representation_item;
+	struct block;
+	struct expression;
+	struct boolean_expression;
+	struct boolean_literal;
+	struct boolean_representation_item;
+	struct boolean_result;
+	struct composite_curve;
+	struct composite_curve_on_surface;
+	struct boundary_curve;
+	struct bounded_pcurve;
+	struct bounded_surface_curve;
+	struct founded_item;
+	struct box_domain;
+	struct half_space_solid;
+	struct boxed_half_space;
+	struct breakdown_context;
+	struct breakdown_element_group_assignment;
+	struct breakdown_element_realization;
+	struct breakdown_element_usage;
+	struct breakdown_of;
+	struct solid_model;
+	struct manifold_solid_brep;
+	struct brep_with_voids;
+	struct bytes_representation_item;
+	struct date;
+	struct calendar_date;
+	struct camera_image;
+	struct camera_image_3d_with_scale;
+	struct camera_model;
+	struct camera_model_d3;
+	struct camera_model_d3_multi_clipping;
+	struct camera_model_d3_multi_clipping_intersection;
+	struct camera_model_d3_multi_clipping_union;
+	struct camera_model_d3_with_hlhsr;
+	struct camera_model_with_light_sources;
+	struct representation_map;
+	struct camera_usage;
+	struct capacitance_measure_with_unit;
+	struct capacitance_unit;
+	struct point;
+	struct cartesian_point;
+	struct cartesian_transformation_operator;
+	struct cartesian_transformation_operator_2d;
+	struct cartesian_transformation_operator_3d;
+	struct cc_design_approval;
+	struct cc_design_certification;
+	struct cc_design_contract;
+	struct cc_design_date_and_time_assignment;
+	struct cc_design_person_and_organization_assignment;
+	struct cc_design_security_classification;
+	struct cc_design_specification_reference;
+	struct celsius_temperature_measure_with_unit;
+	struct centre_of_symmetry;
+	typedef NotImplemented certification; // (not currently used by Assimp)
+	typedef NotImplemented certification_type; // (not currently used by Assimp)
+	struct change;
+	struct change_request;
+	typedef NotImplemented character_glyph_font_usage; // (not currently used by Assimp)
+	struct character_glyph_style_outline;
+	struct character_glyph_style_stroke;
+	struct symbol_representation;
+	struct generic_character_glyph_symbol;
+	struct character_glyph_symbol;
+	struct character_glyph_symbol_outline;
+	struct character_glyph_symbol_stroke;
+	struct general_property;
+	struct characteristic_data_column_header;
+	struct general_property_relationship;
+	struct characteristic_data_column_header_link;
+	struct characteristic_data_table_header;
+	struct characteristic_data_table_header_decomposition;
+	struct group;
+	struct characteristic_type;
+	struct characterized_class;
+	struct characterized_object;
+	struct conic;
+	struct circle;
+	struct circular_runout_tolerance;
+	typedef NotImplemented class_t; // (not currently used by Assimp)
+	struct class_by_extension;
+	struct class_by_intension;
+	struct class_system;
+	struct effectivity_context_assignment;
+	struct class_usage_effectivity_context_assignment;
+	typedef NotImplemented classification_role; // (not currently used by Assimp)
+	struct topological_representation_item;
+	struct connected_face_set;
+	struct closed_shell;
+	struct coaxiality_tolerance;
+	struct colour_specification;
+	struct colour_rgb;
+	struct common_datum;
+	struct comparison_expression;
+	struct complex_clause;
+	struct complex_conjunctive_clause;
+	struct complex_disjunctive_clause;
+	struct modified_solid;
+	struct shelled_solid;
+	struct complex_shelled_solid;
+	struct composite_assembly_definition;
+	struct composite_assembly_sequence_definition;
+	struct laminate_table;
+	struct part_laminate_table;
+	struct composite_assembly_table;
+	struct composite_curve_segment;
+	struct material_designation;
+	struct composite_material_designation;
+	struct composite_shape_aspect;
+	struct composite_sheet_representation;
+	struct composite_text;
+	struct composite_text_with_associated_curves;
+	struct composite_text_with_blanking_box;
+	struct composite_text_with_delineation;
+	struct composite_text_with_extent;
+	struct compound_shape_representation;
+	struct concentricity_tolerance;
+	typedef NotImplemented concept_feature_operator; // (not currently used by Assimp)
+	struct concept_feature_relationship;
+	struct concept_feature_relationship_with_condition;
+	struct product_concept_feature;
+	struct conditional_concept_feature;
+	struct conductance_measure_with_unit;
+	struct conductance_unit;
+	struct configuration_item;
+	struct configurable_item;
+	typedef NotImplemented configuration_design; // (not currently used by Assimp)
+	struct effectivity;
+	struct product_definition_effectivity;
+	struct configuration_effectivity;
+	struct configuration_item_relationship;
+	struct configuration_item_hierarchical_relationship;
+	struct configuration_item_revision_sequence;
+	struct configured_effectivity_assignment;
+	struct configured_effectivity_context_assignment;
+	struct conical_stepped_hole_transition;
+	struct elementary_surface;
+	struct conical_surface;
+	struct connected_edge_set;
+	struct connected_face_sub_set;
+	struct constructive_geometry_representation;
+	struct representation_relationship;
+	struct constructive_geometry_representation_relationship;
+	struct contact_ratio_representation;
+	struct invisibility;
+	struct context_dependent_invisibility;
+	struct over_riding_styled_item;
+	struct context_dependent_over_riding_styled_item;
+	typedef NotImplemented context_dependent_shape_representation; // (not currently used by Assimp)
+	struct context_dependent_unit;
+	typedef NotImplemented contract; // (not currently used by Assimp)
+	typedef NotImplemented contract_relationship; // (not currently used by Assimp)
+	typedef NotImplemented contract_type; // (not currently used by Assimp)
+	struct conversion_based_unit;
+	typedef NotImplemented coordinated_universal_time_offset; // (not currently used by Assimp)
+	struct csg_shape_representation;
+	struct csg_solid;
+	struct currency;
+	struct currency_measure_with_unit;
+	struct curve_bounded_surface;
+	struct curve_dimension;
+	struct curve_replica;
+	struct curve_style;
+	struct curve_style_font;
+	struct curve_style_font_and_scaling;
+	struct curve_style_font_pattern;
+	typedef NotImplemented curve_style_rendering; // (not currently used by Assimp)
+	struct curve_swept_solid_shape_representation;
+	struct cylindrical_surface;
+	struct cylindricity_tolerance;
+	typedef NotImplemented data_environment; // (not currently used by Assimp)
+	typedef NotImplemented date_and_time; // (not currently used by Assimp)
+	struct date_representation_item;
+	typedef NotImplemented date_role; // (not currently used by Assimp)
+	struct date_time_representation_item;
+	typedef NotImplemented date_time_role; // (not currently used by Assimp)
+	struct dated_effectivity;
+	struct datum;
+	struct datum_feature;
+	struct datum_feature_callout;
+	struct datum_reference;
+	struct datum_target;
+	struct datum_target_callout;
+	struct default_tolerance_table;
+	struct default_tolerance_table_cell;
+	struct defined_symbol;
+	struct definitional_representation;
+	struct definitional_representation_relationship;
+	struct definitional_representation_relationship_with_same_context;
+	struct degenerate_pcurve;
+	struct toroidal_surface;
+	struct degenerate_toroidal_surface;
+	typedef NotImplemented derived_unit_element; // (not currently used by Assimp)
+	typedef NotImplemented description_attribute; // (not currently used by Assimp)
+	struct descriptive_representation_item;
+	struct product_definition_context;
+	struct design_context;
+	struct design_make_from_relationship;
+	struct diameter_dimension;
+	struct ratio_measure_with_unit;
+	struct dielectric_constant_measure_with_unit;
+	struct dimension_callout;
+	struct draughting_callout_relationship;
+	struct dimension_callout_component_relationship;
+	struct dimension_callout_relationship;
+	struct dimension_curve;
+	struct terminator_symbol;
+	struct dimension_curve_terminator;
+	struct dimension_curve_terminator_to_projection_curve_associativity;
+	struct dimension_pair;
+	typedef NotImplemented dimension_related_tolerance_zone_element; // (not currently used by Assimp)
+	struct dimension_text_associativity;
+	typedef NotImplemented dimensional_characteristic_representation; // (not currently used by Assimp)
+	typedef NotImplemented dimensional_exponents; // (not currently used by Assimp)
+	struct dimensional_location_with_path;
+	struct dimensional_size_with_path;
+	struct executed_action;
+	struct directed_action;
+	struct directed_dimensional_location;
+	struct direction;
+	typedef NotImplemented document; // (not currently used by Assimp)
+	struct document_file;
+	struct document_identifier;
+	struct document_identifier_assignment;
+	struct document_product_association;
+	struct document_product_equivalence;
+	typedef NotImplemented document_relationship; // (not currently used by Assimp)
+	typedef NotImplemented document_representation_type; // (not currently used by Assimp)
+	typedef NotImplemented document_type; // (not currently used by Assimp)
+	typedef NotImplemented document_usage_constraint; // (not currently used by Assimp)
+	typedef NotImplemented document_usage_role; // (not currently used by Assimp)
+	struct dose_equivalent_measure_with_unit;
+	struct dose_equivalent_unit;
+	struct double_offset_shelled_solid;
+	struct item_defined_transformation;
+	struct transformation_with_derived_angle;
+	struct draped_defined_transformation;
+	struct draughting_annotation_occurrence;
+	struct draughting_elements;
+	struct draughting_model;
+	struct item_identified_representation_usage;
+	struct draughting_model_item_association;
+	struct pre_defined_colour;
+	struct draughting_pre_defined_colour;
+	struct pre_defined_item;
+	struct pre_defined_curve_font;
+	struct draughting_pre_defined_curve_font;
+	struct pre_defined_text_font;
+	struct draughting_pre_defined_text_font;
+	struct draughting_subfigure_representation;
+	struct draughting_symbol_representation;
+	struct text_literal;
+	struct text_literal_with_delineation;
+	struct draughting_text_literal_with_delineation;
+	typedef NotImplemented draughting_title; // (not currently used by Assimp)
+	typedef NotImplemented drawing_definition; // (not currently used by Assimp)
+	struct presentation_set;
+	struct drawing_revision;
+	typedef NotImplemented drawing_revision_sequence; // (not currently used by Assimp)
+	struct presentation_representation;
+	struct presentation_area;
+	struct drawing_sheet_revision;
+	struct drawing_sheet_revision_sequence;
+	struct drawing_sheet_revision_usage;
+	struct edge;
+	struct edge_based_wireframe_model;
+	struct edge_based_wireframe_shape_representation;
+	struct edge_blended_solid;
+	struct edge_curve;
+	struct edge_loop;
+	typedef NotImplemented effectivity_context_role; // (not currently used by Assimp)
+	typedef NotImplemented effectivity_relationship; // (not currently used by Assimp)
+	struct electric_charge_measure_with_unit;
+	struct electric_charge_unit;
+	struct electric_current_measure_with_unit;
+	struct electric_current_unit;
+	struct electric_potential_measure_with_unit;
+	struct electric_potential_unit;
+	struct elementary_brep_shape_representation;
+	struct ellipse;
+	struct energy_measure_with_unit;
+	struct energy_unit;
+	struct property_definition;
+	struct fact_type;
+	struct entity_assertion;
+	struct enum_reference_prefix;
+	typedef NotImplemented environment; // (not currently used by Assimp)
+	struct evaluated_characteristic;
+	struct evaluated_degenerate_pcurve;
+	struct evaluation_product_definition;
+	struct event_occurrence;
+	typedef NotImplemented event_occurrence_relationship; // (not currently used by Assimp)
+	typedef NotImplemented event_occurrence_role; // (not currently used by Assimp)
+	struct product_concept_feature_category;
+	struct exclusive_product_concept_feature_category;
+	struct uncertainty_qualifier;
+	struct standard_uncertainty;
+	struct expanded_uncertainty;
+	struct representation_item_relationship;
+	struct explicit_procedural_representation_item_relationship;
+	struct explicit_procedural_geometric_representation_item_relationship;
+	struct explicit_procedural_representation_relationship;
+	struct explicit_procedural_shape_representation_relationship;
+	struct expression_conversion_based_unit;
+	struct extension;
+	struct extent;
+	struct external_source;
+	struct external_class_library;
+	typedef NotImplemented external_source_relationship; // (not currently used by Assimp)
+	struct externally_defined_class;
+	struct externally_defined_colour;
+	struct externally_defined_context_dependent_unit;
+	struct externally_defined_conversion_based_unit;
+	struct externally_defined_currency;
+	struct externally_defined_item;
+	struct externally_defined_curve_font;
+	struct externally_defined_dimension_definition;
+	struct externally_defined_general_property;
+	struct externally_defined_hatch_style;
+	typedef NotImplemented externally_defined_item_relationship; // (not currently used by Assimp)
+	struct externally_defined_marker;
+	struct picture_representation_item;
+	struct externally_defined_picture_representation_item;
+	struct externally_defined_representation_item;
+	struct externally_defined_string;
+	struct externally_defined_symbol;
+	struct externally_defined_terminator_symbol;
+	struct externally_defined_text_font;
+	struct externally_defined_tile;
+	struct externally_defined_tile_style;
+	struct swept_area_solid;
+	struct extruded_area_solid;
+	struct swept_face_solid;
+	struct extruded_face_solid;
+	struct extruded_face_solid_with_trim_conditions;
+	struct extruded_face_solid_with_draft_angle;
+	struct extruded_face_solid_with_multiple_draft_angles;
+	struct face;
+	struct face_based_surface_model;
+	struct face_bound;
+	struct face_outer_bound;
+	struct faceted_brep;
+	struct faceted_brep_shape_representation;
+	struct fill_area_style;
+	typedef NotImplemented fill_area_style_colour; // (not currently used by Assimp)
+	struct fill_area_style_hatching;
+	struct fill_area_style_tile_coloured_region;
+	struct fill_area_style_tile_curve_with_style;
+	struct fill_area_style_tile_symbol_with_style;
+	struct fill_area_style_tiles;
+	struct shape_representation_relationship;
+	struct flat_pattern_ply_representation_relationship;
+	struct flatness_tolerance;
+	struct force_measure_with_unit;
+	struct force_unit;
+	struct forward_chaining_rule;
+	struct forward_chaining_rule_premise;
+	struct frequency_measure_with_unit;
+	struct frequency_unit;
+	struct func;
+	struct functional_breakdown_context;
+	struct functional_element_usage;
+	typedef NotImplemented functionally_defined_transformation; // (not currently used by Assimp)
+	struct general_material_property;
+	typedef NotImplemented general_property_association; // (not currently used by Assimp)
+	struct simple_generic_expression;
+	struct generic_literal;
+	struct generic_variable;
+	struct geometric_alignment;
+	struct geometric_set;
+	struct geometric_curve_set;
+	struct geometric_intersection;
+	struct geometric_item_specific_usage;
+	struct geometric_model_element_relationship;
+	struct representation_context;
+	struct geometric_representation_context;
+	typedef NotImplemented geometric_tolerance_relationship; // (not currently used by Assimp)
+	struct geometric_tolerance_with_defined_unit;
+	struct geometrical_tolerance_callout;
+	struct geometrically_bounded_2d_wireframe_representation;
+	struct geometrically_bounded_surface_shape_representation;
+	struct geometrically_bounded_wireframe_shape_representation;
+	struct global_assignment;
+	struct global_uncertainty_assigned_context;
+	struct global_unit_assigned_context;
+	struct ground_fact;
+	typedef NotImplemented group_relationship; // (not currently used by Assimp)
+	struct hardness_representation;
+	struct hidden_element_over_riding_styled_item;
+	struct hyperbola;
+	typedef NotImplemented id_attribute; // (not currently used by Assimp)
+	typedef NotImplemented identification_role; // (not currently used by Assimp)
+	struct illuminance_measure_with_unit;
+	struct illuminance_unit;
+	struct included_text_block;
+	struct inclusion_product_concept_feature;
+	struct user_selected_elements;
+	struct indirectly_selected_elements;
+	struct indirectly_selected_shape_elements;
+	struct inductance_measure_with_unit;
+	struct inductance_unit;
+	struct information_right;
+	struct information_usage_right;
+	struct instance_usage_context_assignment;
+	struct instanced_feature;
+	struct literal_number;
+	struct int_literal;
+	struct integer_representation_item;
+	struct surface_curve;
+	struct intersection_curve;
+	struct interval_expression;
+	struct iso4217_currency;
+	struct known_source;
+	struct laid_defined_transformation;
+	struct language;
+	struct leader_curve;
+	struct leader_directed_callout;
+	struct leader_directed_dimension;
+	struct leader_terminator;
+	struct length_measure_with_unit;
+	struct length_unit;
+	struct light_source;
+	struct light_source_ambient;
+	struct light_source_directional;
+	struct light_source_positional;
+	struct light_source_spot;
+	typedef NotImplemented limits_and_fits; // (not currently used by Assimp)
+	struct line;
+	struct line_profile_tolerance;
+	struct linear_dimension;
+	struct simple_clause;
+	struct literal_conjunction;
+	struct literal_disjunction;
+	typedef NotImplemented local_time; // (not currently used by Assimp)
+	struct logical_literal;
+	struct logical_representation_item;
+	struct loop;
+	struct loss_tangent_measure_with_unit;
+	struct lot_effectivity;
+	struct luminous_flux_measure_with_unit;
+	struct luminous_flux_unit;
+	struct luminous_intensity_measure_with_unit;
+	struct luminous_intensity_unit;
+	struct magnetic_flux_density_measure_with_unit;
+	struct magnetic_flux_density_unit;
+	struct magnetic_flux_measure_with_unit;
+	struct magnetic_flux_unit;
+	struct make_from_usage_option;
+	struct manifold_subsurface_shape_representation;
+	struct manifold_surface_shape_representation;
+	struct mass_measure_with_unit;
+	struct mass_unit;
+	typedef NotImplemented material_designation_characterization; // (not currently used by Assimp)
+	struct material_property;
+	struct property_definition_representation;
+	struct material_property_representation;
+	typedef NotImplemented measure_qualification; // (not currently used by Assimp)
+	struct measure_representation_item;
+	struct product_context;
+	struct mechanical_context;
+	struct mechanical_design_and_draughting_relationship;
+	struct mechanical_design_geometric_presentation_area;
+	struct mechanical_design_geometric_presentation_representation;
+	struct mechanical_design_presentation_representation_with_draughting;
+	struct mechanical_design_shaded_presentation_area;
+	struct mechanical_design_shaded_presentation_representation;
+	struct min_and_major_ply_orientation_basis;
+	struct modified_geometric_tolerance;
+	struct modified_solid_with_placed_configuration;
+	struct moments_of_inertia_representation;
+	struct multi_language_attribute_assignment;
+	struct multiple_arity_boolean_expression;
+	struct multiple_arity_generic_expression;
+	struct multiple_arity_numeric_expression;
+	typedef NotImplemented name_attribute; // (not currently used by Assimp)
+	struct next_assembly_usage_occurrence;
+	struct non_manifold_surface_shape_representation;
+	struct null_representation_item;
+	struct numeric_expression;
+	typedef NotImplemented object_role; // (not currently used by Assimp)
+	struct offset_curve_2d;
+	struct offset_curve_3d;
+	struct offset_surface;
+	struct one_direction_repeat_factor;
+	struct open_shell;
+	struct ordinal_date;
+	struct projection_directed_callout;
+	struct ordinate_dimension;
+	typedef NotImplemented organization; // (not currently used by Assimp)
+	typedef NotImplemented organization_relationship; // (not currently used by Assimp)
+	typedef NotImplemented organization_role; // (not currently used by Assimp)
+	struct organizational_address;
+	typedef NotImplemented organizational_project; // (not currently used by Assimp)
+	typedef NotImplemented organizational_project_relationship; // (not currently used by Assimp)
+	typedef NotImplemented organizational_project_role; // (not currently used by Assimp)
+	struct oriented_closed_shell;
+	struct oriented_edge;
+	struct oriented_face;
+	struct oriented_open_shell;
+	struct path;
+	struct oriented_path;
+	struct oriented_surface;
+	struct outer_boundary_curve;
+	struct package_product_concept_feature;
+	struct parabola;
+	struct parallel_offset;
+	struct parallelism_tolerance;
+	struct parametric_representation_context;
+	struct partial_document_with_structured_text_representation_assignment;
+	struct pcurve;
+	struct percentage_laminate_definition;
+	struct zone_structural_makeup;
+	struct percentage_laminate_table;
+	struct percentage_ply_definition;
+	struct perpendicular_to;
+	struct perpendicularity_tolerance;
+	typedef NotImplemented person; // (not currently used by Assimp)
+	typedef NotImplemented person_and_organization; // (not currently used by Assimp)
+	struct person_and_organization_address;
+	typedef NotImplemented person_and_organization_role; // (not currently used by Assimp)
+	struct personal_address;
+	struct physical_breakdown_context;
+	struct physical_element_usage;
+	struct presentation_view;
+	struct picture_representation;
+	struct placed_datum_target_feature;
+	struct placed_feature;
+	struct planar_extent;
+	struct planar_box;
+	struct plane;
+	struct plane_angle_measure_with_unit;
+	struct plane_angle_unit;
+	typedef NotImplemented plus_minus_tolerance; // (not currently used by Assimp)
+	struct ply_laminate_definition;
+	struct ply_laminate_sequence_definition;
+	struct ply_laminate_table;
+	struct point_and_vector;
+	struct point_on_curve;
+	struct point_on_surface;
+	struct point_path;
+	struct point_replica;
+	struct point_style;
+	struct polar_complex_number_literal;
+	struct poly_loop;
+	struct polyline;
+	struct position_tolerance;
+	struct positioned_sketch;
+	struct power_measure_with_unit;
+	struct power_unit;
+	struct pre_defined_symbol;
+	struct pre_defined_dimension_symbol;
+	struct pre_defined_geometrical_tolerance_symbol;
+	struct pre_defined_marker;
+	struct pre_defined_point_marker_symbol;
+	struct pre_defined_surface_condition_symbol;
+	struct pre_defined_surface_side_style;
+	struct pre_defined_terminator_symbol;
+	struct pre_defined_tile;
+	typedef NotImplemented precision_qualifier; // (not currently used by Assimp)
+	struct predefined_picture_representation_item;
+	typedef NotImplemented presentation_layer_assignment; // (not currently used by Assimp)
+	typedef NotImplemented presentation_size; // (not currently used by Assimp)
+	struct presentation_style_assignment;
+	struct presentation_style_by_context;
+	typedef NotImplemented presented_item_representation; // (not currently used by Assimp)
+	struct pressure_measure_with_unit;
+	struct pressure_unit;
+	struct procedural_representation;
+	struct procedural_representation_sequence;
+	struct procedural_shape_representation;
+	struct procedural_shape_representation_sequence;
+	typedef NotImplemented product; // (not currently used by Assimp)
+	struct product_category;
+	struct product_class;
+	typedef NotImplemented product_concept; // (not currently used by Assimp)
+	struct product_concept_context;
+	typedef NotImplemented product_concept_feature_association; // (not currently used by Assimp)
+	struct product_concept_feature_category_usage;
+	typedef NotImplemented product_concept_relationship; // (not currently used by Assimp)
+	typedef NotImplemented product_definition_context_association; // (not currently used by Assimp)
+	typedef NotImplemented product_definition_context_role; // (not currently used by Assimp)
+	struct product_definition_element_relationship;
+	struct product_definition_formation;
+	typedef NotImplemented product_definition_formation_relationship; // (not currently used by Assimp)
+	struct product_definition_formation_with_specified_source;
+	struct product_definition_group_assignment;
+	typedef NotImplemented product_definition_occurrence_relationship; // (not currently used by Assimp)
+	struct product_definition_shape;
+	typedef NotImplemented product_definition_substitute; // (not currently used by Assimp)
+	struct product_definition_with_associated_documents;
+	struct product_identification;
+	struct product_material_composition_relationship;
+	struct product_related_product_category;
+	struct product_specification;
+	struct tolerance_zone_definition;
+	struct projected_zone_definition;
+	struct projection_curve;
+	struct promissory_usage_occurrence;
+	typedef NotImplemented property_definition_relationship; // (not currently used by Assimp)
+	struct qualified_representation_item;
+	struct qualitative_uncertainty;
+	struct quantified_assembly_component_usage;
+	struct quasi_uniform_curve;
+	struct quasi_uniform_surface;
+	struct radioactivity_measure_with_unit;
+	struct radioactivity_unit;
+	struct radius_dimension;
+	struct range_characteristic;
+	struct ratio_unit;
+	struct rational_b_spline_curve;
+	struct rational_b_spline_surface;
+	struct rational_representation_item;
+	struct real_literal;
+	struct real_representation_item;
+	struct rectangular_composite_surface;
+	struct rectangular_trimmed_surface;
+	struct referenced_modified_datum;
+	struct relative_event_occurrence;
+	struct rep_item_group;
+	struct reparametrised_composite_curve_segment;
+	struct representation_relationship_with_transformation;
+	struct requirement_assigned_object;
+	struct requirement_assignment;
+	struct requirement_source;
+	struct requirement_view_definition_relationship;
+	struct resistance_measure_with_unit;
+	struct resistance_unit;
+	struct revolved_area_solid;
+	struct revolved_face_solid;
+	struct revolved_face_solid_with_trim_conditions;
+	struct right_angular_wedge;
+	struct right_circular_cone;
+	struct right_circular_cylinder;
+	struct right_to_usage_association;
+	typedef NotImplemented role_association; // (not currently used by Assimp)
+	struct roundness_tolerance;
+	struct row_representation_item;
+	struct row_value;
+	struct row_variable;
+	struct rule_action;
+	struct rule_condition;
+	struct rule_set;
+	struct rule_set_group;
+	struct rule_superseded_assignment;
+	struct rule_supersedence;
+	struct surface_curve_swept_area_solid;
+	struct ruled_surface_swept_area_solid;
+	struct runout_zone_definition;
+	struct runout_zone_orientation;
+	struct runout_zone_orientation_reference_direction;
+	struct satisfied_requirement;
+	struct satisfies_requirement;
+	struct satisfying_item;
+	struct scalar_variable;
+	struct scattering_parameter;
+	struct sculptured_solid;
+	struct seam_curve;
+	typedef NotImplemented security_classification; // (not currently used by Assimp)
+	typedef NotImplemented security_classification_level; // (not currently used by Assimp)
+	struct serial_numbered_effectivity;
+	struct shape_aspect_associativity;
+	struct shape_aspect_deriving_relationship;
+	struct shape_definition_representation;
+	struct shape_dimension_representation;
+	struct shape_feature_definition;
+	struct shape_representation_with_parameters;
+	struct shell_based_surface_model;
+	struct shell_based_wireframe_model;
+	struct shell_based_wireframe_shape_representation;
+	struct si_absorbed_dose_unit;
+	struct si_capacitance_unit;
+	struct si_conductance_unit;
+	struct si_dose_equivalent_unit;
+	struct si_electric_charge_unit;
+	struct si_electric_potential_unit;
+	struct si_energy_unit;
+	struct si_force_unit;
+	struct si_frequency_unit;
+	struct si_illuminance_unit;
+	struct si_inductance_unit;
+	struct si_magnetic_flux_density_unit;
+	struct si_magnetic_flux_unit;
+	struct si_power_unit;
+	struct si_pressure_unit;
+	struct si_radioactivity_unit;
+	struct si_resistance_unit;
+	struct si_unit;
+	struct simple_boolean_expression;
+	struct simple_numeric_expression;
+	struct slash_expression;
+	struct smeared_material_definition;
+	struct solid_angle_measure_with_unit;
+	struct solid_angle_unit;
+	struct solid_curve_font;
+	struct solid_replica;
+	struct solid_with_chamfered_edges;
+	struct solid_with_angle_based_chamfer;
+	struct solid_with_shape_element_pattern;
+	struct solid_with_circular_pattern;
+	struct solid_with_depression;
+	struct solid_with_pocket;
+	struct solid_with_circular_pocket;
+	struct solid_with_protrusion;
+	struct solid_with_circular_protrusion;
+	struct solid_with_hole;
+	struct solid_with_stepped_round_hole;
+	struct solid_with_conical_bottom_round_hole;
+	struct solid_with_constant_radius_edge_blend;
+	struct solid_with_slot;
+	struct solid_with_curved_slot;
+	struct solid_with_double_offset_chamfer;
+	struct solid_with_flat_bottom_round_hole;
+	struct solid_with_general_pocket;
+	struct solid_with_general_protrusion;
+	struct solid_with_groove;
+	struct solid_with_incomplete_circular_pattern;
+	struct solid_with_rectangular_pattern;
+	struct solid_with_incomplete_rectangular_pattern;
+	struct solid_with_rectangular_pocket;
+	struct solid_with_rectangular_protrusion;
+	struct solid_with_single_offset_chamfer;
+	struct solid_with_spherical_bottom_round_hole;
+	struct solid_with_stepped_round_hole_and_conical_transitions;
+	struct solid_with_straight_slot;
+	struct solid_with_tee_section_slot;
+	struct solid_with_through_depression;
+	struct solid_with_trapezoidal_section_slot;
+	struct solid_with_variable_radius_edge_blend;
+	struct source_for_requirement;
+	struct sourced_requirement;
+	struct specification_definition;
+	struct specified_higher_usage_occurrence;
+	struct sphere;
+	struct spherical_surface;
+	struct start_request;
+	struct start_work;
+	struct straightness_tolerance;
+	struct structured_dimension_callout;
+	struct structured_text_composition;
+	struct structured_text_representation;
+	struct subedge;
+	struct subface;
+	struct supplied_part_relationship;
+	struct surface_condition_callout;
+	struct swept_surface;
+	struct surface_of_linear_extrusion;
+	struct surface_of_revolution;
+	struct surface_patch;
+	struct surface_profile_tolerance;
+	typedef NotImplemented surface_rendering_properties; // (not currently used by Assimp)
+	struct surface_replica;
+	struct surface_side_style;
+	struct surface_style_boundary;
+	struct surface_style_control_grid;
+	struct surface_style_fill_area;
+	struct surface_style_parameter_line;
+	struct surface_style_reflectance_ambient;
+	struct surface_style_reflectance_ambient_diffuse;
+	struct surface_style_reflectance_ambient_diffuse_specular;
+	struct surface_style_rendering;
+	struct surface_style_rendering_with_properties;
+	struct surface_style_segmentation_curve;
+	struct surface_style_silhouette;
+	typedef NotImplemented surface_style_transparent; // (not currently used by Assimp)
+	struct surface_style_usage;
+	struct surface_texture_representation;
+	struct surfaced_open_shell;
+	struct swept_disk_solid;
+	struct symbol;
+	typedef NotImplemented symbol_colour; // (not currently used by Assimp)
+	struct symbol_representation_map;
+	struct symbol_style;
+	struct symbol_target;
+	struct symmetric_shape_aspect;
+	struct symmetry_tolerance;
+	struct table_representation_item;
+	struct tactile_appearance_representation;
+	struct tagged_text_format;
+	struct tagged_text_item;
+	struct tangent;
+	typedef NotImplemented text_font; // (not currently used by Assimp)
+	typedef NotImplemented text_font_family; // (not currently used by Assimp)
+	typedef NotImplemented text_font_in_family; // (not currently used by Assimp)
+	struct text_literal_with_associated_curves;
+	struct text_literal_with_blanking_box;
+	struct text_literal_with_extent;
+	struct text_string_representation;
+	struct text_style;
+	typedef NotImplemented text_style_for_defined_font; // (not currently used by Assimp)
+	struct text_style_with_box_characteristics;
+	struct text_style_with_mirror;
+	struct text_style_with_spacing;
+	struct thermal_resistance_measure_with_unit;
+	struct thermal_resistance_unit;
+	struct thermodynamic_temperature_measure_with_unit;
+	struct thermodynamic_temperature_unit;
+	struct thickened_face_solid;
+	struct thickness_laminate_definition;
+	struct thickness_laminate_table;
+	struct time_interval;
+	struct time_interval_based_effectivity;
+	typedef NotImplemented time_interval_relationship; // (not currently used by Assimp)
+	typedef NotImplemented time_interval_role; // (not currently used by Assimp)
+	struct time_interval_with_bounds;
+	struct time_measure_with_unit;
+	struct time_unit;
+	typedef NotImplemented tolerance_value; // (not currently used by Assimp)
+	struct tolerance_zone;
+	typedef NotImplemented tolerance_zone_form; // (not currently used by Assimp)
+	struct torus;
+	struct total_runout_tolerance;
+	struct track_blended_solid;
+	struct track_blended_solid_with_end_conditions;
+	struct trimmed_curve;
+	struct two_direction_repeat_factor;
+	typedef NotImplemented type_qualifier; // (not currently used by Assimp)
+	struct unary_generic_expression;
+	struct unary_numeric_expression;
+	struct uncertainty_assigned_representation;
+	struct uncertainty_measure_with_unit;
+	struct uniform_curve;
+	struct uniform_resource_identifier;
+	struct uniform_surface;
+	struct usage_association;
+	struct user_defined_curve_font;
+	struct user_defined_marker;
+	struct user_defined_terminator_symbol;
+	struct user_selected_shape_elements;
+	struct value_range;
+	struct value_representation_item;
+	struct variable_semantics;
+	struct variational_representation_item;
+	struct vector;
+	struct vector_style;
+	struct velocity_measure_with_unit;
+	struct velocity_unit;
+	typedef NotImplemented versioned_action_request; // (not currently used by Assimp)
+	struct vertex;
+	struct vertex_loop;
+	struct vertex_point;
+	struct vertex_shell;
+	struct view_volume;
+	struct visual_appearance_representation;
+	struct volume_measure_with_unit;
+	struct volume_unit;
+	struct week_of_year_and_day_date;
+	struct wire_shell;
+	struct year_month;
+
+
+
+    // C++ wrapper for measure_with_unit
+    struct measure_with_unit :  ObjectHelper<measure_with_unit,2> { measure_with_unit() : Object("measure_with_unit") {}
+		measure_value::Out value_component;
+		unit::Out unit_component;
+    };
+
+    // C++ wrapper for absorbed_dose_measure_with_unit
+    struct absorbed_dose_measure_with_unit : measure_with_unit, ObjectHelper<absorbed_dose_measure_with_unit,0> { absorbed_dose_measure_with_unit() : Object("absorbed_dose_measure_with_unit") {}
+
+    };
+
+    // C++ wrapper for derived_unit
+    struct derived_unit :  ObjectHelper<derived_unit,1> { derived_unit() : Object("derived_unit") {}
+		ListOf< Lazy< NotImplemented >, 1, 0 > elements;
+    };
+
+    // C++ wrapper for absorbed_dose_unit
+    struct absorbed_dose_unit : derived_unit, ObjectHelper<absorbed_dose_unit,0> { absorbed_dose_unit() : Object("absorbed_dose_unit") {}
+
+    };
+
+    // C++ wrapper for abstract_variable
+    struct abstract_variable :  ObjectHelper<abstract_variable,0> { abstract_variable() : Object("abstract_variable") {}
+
+    };
+
+    // C++ wrapper for acceleration_measure_with_unit
+    struct acceleration_measure_with_unit : measure_with_unit, ObjectHelper<acceleration_measure_with_unit,0> { acceleration_measure_with_unit() : Object("acceleration_measure_with_unit") {}
+
+    };
+
+    // C++ wrapper for acceleration_unit
+    struct acceleration_unit : derived_unit, ObjectHelper<acceleration_unit,0> { acceleration_unit() : Object("acceleration_unit") {}
+
+    };
+
+    // C++ wrapper for action
+    struct action :  ObjectHelper<action,3> { action() : Object("action") {}
+		label::Out name;
+		Maybe< text::Out > description;
+		Lazy< action_method > chosen_method;
+    };
+
+    // C++ wrapper for action_assignment
+    struct action_assignment :  ObjectHelper<action_assignment,1> { action_assignment() : Object("action_assignment") {}
+		Lazy< action > assigned_action;
+    };
+
+    // C++ wrapper for action_method
+    struct action_method :  ObjectHelper<action_method,4> { action_method() : Object("action_method") {}
+		label::Out name;
+		Maybe< text::Out > description;
+		text::Out consequence;
+		text::Out purpose;
+    };
+
+    // C++ wrapper for action_method_assignment
+    struct action_method_assignment :  ObjectHelper<action_method_assignment,2> { action_method_assignment() : Object("action_method_assignment") {}
+		Lazy< action_method > assigned_action_method;
+		Lazy< NotImplemented > role;
+    };
+
+    // C++ wrapper for action_method_relationship
+    struct action_method_relationship :  ObjectHelper<action_method_relationship,4> { action_method_relationship() : Object("action_method_relationship") {}
+		label::Out name;
+		Maybe< text::Out > description;
+		Lazy< action_method > relating_method;
+		Lazy< action_method > related_method;
+    };
+
+    // C++ wrapper for action_request_assignment
+    struct action_request_assignment :  ObjectHelper<action_request_assignment,1> { action_request_assignment() : Object("action_request_assignment") {}
+		Lazy< NotImplemented > assigned_action_request;
+    };
+
+    // C++ wrapper for address
+    struct address :  ObjectHelper<address,12> { address() : Object("address") {}
+		Maybe< label::Out > internal_location;
+		Maybe< label::Out > street_number;
+		Maybe< label::Out > street;
+		Maybe< label::Out > postal_box;
+		Maybe< label::Out > town;
+		Maybe< label::Out > region;
+		Maybe< label::Out > postal_code;
+		Maybe< label::Out > country;
+		Maybe< label::Out > facsimile_number;
+		Maybe< label::Out > telephone_number;
+		Maybe< label::Out > electronic_mail_address;
+		Maybe< label::Out > telex_number;
+    };
+
+    // C++ wrapper for representation
+    struct representation :  ObjectHelper<representation,3> { representation() : Object("representation") {}
+		label::Out name;
+		ListOf< Lazy< representation_item >, 1, 0 > items;
+		Lazy< representation_context > context_of_items;
+    };
+
+    // C++ wrapper for shape_representation
+    struct shape_representation : representation, ObjectHelper<shape_representation,0> { shape_representation() : Object("shape_representation") {}
+
+    };
+
+    // C++ wrapper for advanced_brep_shape_representation
+    struct advanced_brep_shape_representation : shape_representation, ObjectHelper<advanced_brep_shape_representation,0> { advanced_brep_shape_representation() : Object("advanced_brep_shape_representation") {}
+
+    };
+
+    // C++ wrapper for face_surface
+    struct face_surface :  ObjectHelper<face_surface,2> { face_surface() : Object("face_surface") {}
+		Lazy< surface > face_geometry;
+		BOOLEAN::Out same_sense;
+    };
+
+    // C++ wrapper for advanced_face
+    struct advanced_face : face_surface, ObjectHelper<advanced_face,0> { advanced_face() : Object("advanced_face") {}
+
+    };
+
+    // C++ wrapper for amount_of_substance_measure_with_unit
+    struct amount_of_substance_measure_with_unit : measure_with_unit, ObjectHelper<amount_of_substance_measure_with_unit,0> { amount_of_substance_measure_with_unit() : Object("amount_of_substance_measure_with_unit") {}
+
+    };
+
+    // C++ wrapper for named_unit
+    struct named_unit :  ObjectHelper<named_unit,1> { named_unit() : Object("named_unit") {}
+		Lazy< NotImplemented > dimensions;
+    };
+
+    // C++ wrapper for amount_of_substance_unit
+    struct amount_of_substance_unit : named_unit, ObjectHelper<amount_of_substance_unit,0> { amount_of_substance_unit() : Object("amount_of_substance_unit") {}
+
+    };
+
+    // C++ wrapper for angle_direction_reference
+    struct angle_direction_reference :  ObjectHelper<angle_direction_reference,0> { angle_direction_reference() : Object("angle_direction_reference") {}
+
+    };
+
+    // C++ wrapper for representation_item
+    struct representation_item :  ObjectHelper<representation_item,1> { representation_item() : Object("representation_item") {}
+		label::Out name;
+    };
+
+    // C++ wrapper for geometric_representation_item
+    struct geometric_representation_item : representation_item, ObjectHelper<geometric_representation_item,0> { geometric_representation_item() : Object("geometric_representation_item") {}
+
+    };
+
+    // C++ wrapper for draughting_callout
+    struct draughting_callout : geometric_representation_item, ObjectHelper<draughting_callout,1> { draughting_callout() : Object("draughting_callout") {}
+		ListOf< draughting_callout_element, 1, 0 >::Out contents;
+    };
+
+    // C++ wrapper for dimension_curve_directed_callout
+    struct dimension_curve_directed_callout : draughting_callout, ObjectHelper<dimension_curve_directed_callout,0> { dimension_curve_directed_callout() : Object("dimension_curve_directed_callout") {}
+
+    };
+
+    // C++ wrapper for angular_dimension
+    struct angular_dimension : dimension_curve_directed_callout, ObjectHelper<angular_dimension,0> { angular_dimension() : Object("angular_dimension") {}
+
+    };
+
+    // C++ wrapper for shape_aspect_relationship
+    struct shape_aspect_relationship :  ObjectHelper<shape_aspect_relationship,4> { shape_aspect_relationship() : Object("shape_aspect_relationship") {}
+		label::Out name;
+		Maybe< text::Out > description;
+		Lazy< shape_aspect > relating_shape_aspect;
+		Lazy< shape_aspect > related_shape_aspect;
+    };
+
+    // C++ wrapper for dimensional_location
+    struct dimensional_location : shape_aspect_relationship, ObjectHelper<dimensional_location,0> { dimensional_location() : Object("dimensional_location") {}
+
+    };
+
+    // C++ wrapper for angular_location
+    struct angular_location : dimensional_location, ObjectHelper<angular_location,1> { angular_location() : Object("angular_location") {}
+		angle_relator::Out angle_selection;
+    };
+
+    // C++ wrapper for dimensional_size
+    struct dimensional_size :  ObjectHelper<dimensional_size,2> { dimensional_size() : Object("dimensional_size") {}
+		Lazy< shape_aspect > applies_to;
+		label::Out name;
+    };
+
+    // C++ wrapper for angular_size
+    struct angular_size : dimensional_size, ObjectHelper<angular_size,1> { angular_size() : Object("angular_size") {}
+		angle_relator::Out angle_selection;
+    };
+
+    // C++ wrapper for geometric_tolerance
+    struct geometric_tolerance :  ObjectHelper<geometric_tolerance,4> { geometric_tolerance() : Object("geometric_tolerance") {}
+		label::Out name;
+		text::Out description;
+		Lazy< measure_with_unit > magnitude;
+		Lazy< shape_aspect > toleranced_shape_aspect;
+    };
+
+    // C++ wrapper for geometric_tolerance_with_datum_reference
+    struct geometric_tolerance_with_datum_reference : geometric_tolerance, ObjectHelper<geometric_tolerance_with_datum_reference,1> { geometric_tolerance_with_datum_reference() : Object("geometric_tolerance_with_datum_reference") {}
+		ListOf< Lazy< datum_reference >, 1, 0 > datum_system;
+    };
+
+    // C++ wrapper for angularity_tolerance
+    struct angularity_tolerance : geometric_tolerance_with_datum_reference, ObjectHelper<angularity_tolerance,0> { angularity_tolerance() : Object("angularity_tolerance") {}
+
+    };
+
+    // C++ wrapper for styled_item
+    struct styled_item : representation_item, ObjectHelper<styled_item,2> { styled_item() : Object("styled_item") {}
+		ListOf< Lazy< presentation_style_assignment >, 1, 0 > styles;
+		Lazy< representation_item > item;
+    };
+
+    // C++ wrapper for annotation_occurrence
+    struct annotation_occurrence : styled_item, ObjectHelper<annotation_occurrence,0> { annotation_occurrence() : Object("annotation_occurrence") {}
+
+    };
+
+    // C++ wrapper for annotation_curve_occurrence
+    struct annotation_curve_occurrence : annotation_occurrence, ObjectHelper<annotation_curve_occurrence,0> { annotation_curve_occurrence() : Object("annotation_curve_occurrence") {}
+
+    };
+
+    // C++ wrapper for annotation_fill_area
+    struct annotation_fill_area : geometric_representation_item, ObjectHelper<annotation_fill_area,1> { annotation_fill_area() : Object("annotation_fill_area") {}
+		ListOf< Lazy< curve >, 1, 0 > boundaries;
+    };
+
+    // C++ wrapper for annotation_fill_area_occurrence
+    struct annotation_fill_area_occurrence : annotation_occurrence, ObjectHelper<annotation_fill_area_occurrence,1> { annotation_fill_area_occurrence() : Object("annotation_fill_area_occurrence") {}
+		Lazy< point > fill_style_target;
+    };
+
+    // C++ wrapper for annotation_occurrence_relationship
+    struct annotation_occurrence_relationship :  ObjectHelper<annotation_occurrence_relationship,4> { annotation_occurrence_relationship() : Object("annotation_occurrence_relationship") {}
+		label::Out name;
+		text::Out description;
+		Lazy< annotation_occurrence > relating_annotation_occurrence;
+		Lazy< annotation_occurrence > related_annotation_occurrence;
+    };
+
+    // C++ wrapper for annotation_occurrence_associativity
+    struct annotation_occurrence_associativity : annotation_occurrence_relationship, ObjectHelper<annotation_occurrence_associativity,0> { annotation_occurrence_associativity() : Object("annotation_occurrence_associativity") {}
+
+    };
+
+    // C++ wrapper for annotation_plane
+    struct annotation_plane :  ObjectHelper<annotation_plane,1> { annotation_plane() : Object("annotation_plane") {}
+		Maybe< ListOf< annotation_plane_element, 1, 0 >::Out > elements;
+    };
+
+    // C++ wrapper for annotation_symbol_occurrence
+    struct annotation_symbol_occurrence : annotation_occurrence, ObjectHelper<annotation_symbol_occurrence,0> { annotation_symbol_occurrence() : Object("annotation_symbol_occurrence") {}
+
+    };
+
+    // C++ wrapper for annotation_subfigure_occurrence
+    struct annotation_subfigure_occurrence : annotation_symbol_occurrence, ObjectHelper<annotation_subfigure_occurrence,0> { annotation_subfigure_occurrence() : Object("annotation_subfigure_occurrence") {}
+
+    };
+
+    // C++ wrapper for mapped_item
+    struct mapped_item : representation_item, ObjectHelper<mapped_item,2> { mapped_item() : Object("mapped_item") {}
+		Lazy< representation_map > mapping_source;
+		Lazy< representation_item > mapping_target;
+    };
+
+    // C++ wrapper for annotation_symbol
+    struct annotation_symbol : mapped_item, ObjectHelper<annotation_symbol,0> { annotation_symbol() : Object("annotation_symbol") {}
+
+    };
+
+    // C++ wrapper for annotation_text
+    struct annotation_text : mapped_item, ObjectHelper<annotation_text,0> { annotation_text() : Object("annotation_text") {}
+
+    };
+
+    // C++ wrapper for annotation_text_character
+    struct annotation_text_character : mapped_item, ObjectHelper<annotation_text_character,1> { annotation_text_character() : Object("annotation_text_character") {}
+		text_alignment::Out alignment;
+    };
+
+    // C++ wrapper for annotation_text_occurrence
+    struct annotation_text_occurrence : annotation_occurrence, ObjectHelper<annotation_text_occurrence,0> { annotation_text_occurrence() : Object("annotation_text_occurrence") {}
+
+    };
+
+    // C++ wrapper for shape_aspect
+    struct shape_aspect :  ObjectHelper<shape_aspect,4> { shape_aspect() : Object("shape_aspect") {}
+		label::Out name;
+		Maybe< text::Out > description;
+		Lazy< product_definition_shape > of_shape;
+		LOGICAL::Out product_definitional;
+    };
+
+    // C++ wrapper for derived_shape_aspect
+    struct derived_shape_aspect : shape_aspect, ObjectHelper<derived_shape_aspect,0> { derived_shape_aspect() : Object("derived_shape_aspect") {}
+
+    };
+
+    // C++ wrapper for apex
+    struct apex : derived_shape_aspect, ObjectHelper<apex,0> { apex() : Object("apex") {}
+
+    };
+
+    // C++ wrapper for application_context_element
+    struct application_context_element :  ObjectHelper<application_context_element,2> { application_context_element() : Object("application_context_element") {}
+		label::Out name;
+		Lazy< NotImplemented > frame_of_reference;
+    };
+
+    // C++ wrapper for applied_action_assignment
+    struct applied_action_assignment : action_assignment, ObjectHelper<applied_action_assignment,1> { applied_action_assignment() : Object("applied_action_assignment") {}
+		ListOf< action_items, 1, 0 >::Out items;
+    };
+
+    // C++ wrapper for applied_action_method_assignment
+    struct applied_action_method_assignment : action_method_assignment, ObjectHelper<applied_action_method_assignment,1> { applied_action_method_assignment() : Object("applied_action_method_assignment") {}
+		ListOf< action_method_items, 1, 0 >::Out items;
+    };
+
+    // C++ wrapper for applied_action_request_assignment
+    struct applied_action_request_assignment : action_request_assignment, ObjectHelper<applied_action_request_assignment,1> { applied_action_request_assignment() : Object("applied_action_request_assignment") {}
+		ListOf< action_request_item, 1, 0 >::Out items;
+    };
+
+    // C++ wrapper for approval_assignment
+    struct approval_assignment :  ObjectHelper<approval_assignment,1> { approval_assignment() : Object("approval_assignment") {}
+		Lazy< NotImplemented > assigned_approval;
+    };
+
+    // C++ wrapper for applied_approval_assignment
+    struct applied_approval_assignment : approval_assignment, ObjectHelper<applied_approval_assignment,1> { applied_approval_assignment() : Object("applied_approval_assignment") {}
+		ListOf< approval_item, 1, 0 >::Out items;
+    };
+
+    // C++ wrapper for attribute_classification_assignment
+    struct attribute_classification_assignment :  ObjectHelper<attribute_classification_assignment,3> { attribute_classification_assignment() : Object("attribute_classification_assignment") {}
+		Lazy< group > assigned_class;
+		label::Out attribute_name;
+		Lazy< NotImplemented > role;
+    };
+
+    // C++ wrapper for applied_attribute_classification_assignment
+    struct applied_attribute_classification_assignment : attribute_classification_assignment, ObjectHelper<applied_attribute_classification_assignment,1> { applied_attribute_classification_assignment() : Object("applied_attribute_classification_assignment") {}
+		ListOf< attribute_classification_item, 1, 0 >::Out items;
+    };
+
+    // C++ wrapper for certification_assignment
+    struct certification_assignment :  ObjectHelper<certification_assignment,1> { certification_assignment() : Object("certification_assignment") {}
+		Lazy< NotImplemented > assigned_certification;
+    };
+
+    // C++ wrapper for applied_certification_assignment
+    struct applied_certification_assignment : certification_assignment, ObjectHelper<applied_certification_assignment,1> { applied_certification_assignment() : Object("applied_certification_assignment") {}
+		ListOf< certification_item, 1, 0 >::Out items;
+    };
+
+    // C++ wrapper for classification_assignment
+    struct classification_assignment :  ObjectHelper<classification_assignment,2> { classification_assignment() : Object("classification_assignment") {}
+		Lazy< group > assigned_class;
+		Lazy< NotImplemented > role;
+    };
+
+    // C++ wrapper for applied_classification_assignment
+    struct applied_classification_assignment : classification_assignment, ObjectHelper<applied_classification_assignment,1> { applied_classification_assignment() : Object("applied_classification_assignment") {}
+		ListOf< classification_item, 1, 0 >::Out items;
+    };
+
+    // C++ wrapper for contract_assignment
+    struct contract_assignment :  ObjectHelper<contract_assignment,1> { contract_assignment() : Object("contract_assignment") {}
+		Lazy< NotImplemented > assigned_contract;
+    };
+
+    // C++ wrapper for applied_contract_assignment
+    struct applied_contract_assignment : contract_assignment, ObjectHelper<applied_contract_assignment,1> { applied_contract_assignment() : Object("applied_contract_assignment") {}
+		ListOf< contract_item, 1, 0 >::Out items;
+    };
+
+    // C++ wrapper for date_and_time_assignment
+    struct date_and_time_assignment :  ObjectHelper<date_and_time_assignment,2> { date_and_time_assignment() : Object("date_and_time_assignment") {}
+		Lazy< NotImplemented > assigned_date_and_time;
+		Lazy< NotImplemented > role;
+    };
+
+    // C++ wrapper for applied_date_and_time_assignment
+    struct applied_date_and_time_assignment : date_and_time_assignment, ObjectHelper<applied_date_and_time_assignment,1> { applied_date_and_time_assignment() : Object("applied_date_and_time_assignment") {}
+		ListOf< date_and_time_item, 1, 0 >::Out items;
+    };
+
+    // C++ wrapper for date_assignment
+    struct date_assignment :  ObjectHelper<date_assignment,2> { date_assignment() : Object("date_assignment") {}
+		Lazy< date > assigned_date;
+		Lazy< NotImplemented > role;
+    };
+
+    // C++ wrapper for applied_date_assignment
+    struct applied_date_assignment : date_assignment, ObjectHelper<applied_date_assignment,1> { applied_date_assignment() : Object("applied_date_assignment") {}
+		ListOf< date_item, 1, 0 >::Out items;
+    };
+
+    // C++ wrapper for document_reference
+    struct document_reference :  ObjectHelper<document_reference,2> { document_reference() : Object("document_reference") {}
+		Lazy< NotImplemented > assigned_document;
+		label::Out source;
+    };
+
+    // C++ wrapper for applied_document_reference
+    struct applied_document_reference : document_reference, ObjectHelper<applied_document_reference,1> { applied_document_reference() : Object("applied_document_reference") {}
+		ListOf< document_reference_item, 1, 0 >::Out items;
+    };
+
+    // C++ wrapper for document_usage_constraint_assignment
+    struct document_usage_constraint_assignment :  ObjectHelper<document_usage_constraint_assignment,2> { document_usage_constraint_assignment() : Object("document_usage_constraint_assignment") {}
+		Lazy< NotImplemented > assigned_document_usage;
+		Lazy< NotImplemented > role;
+    };
+
+    // C++ wrapper for applied_document_usage_constraint_assignment
+    struct applied_document_usage_constraint_assignment : document_usage_constraint_assignment, ObjectHelper<applied_document_usage_constraint_assignment,1> { applied_document_usage_constraint_assignment() : Object("applied_document_usage_constraint_assignment") {}
+		ListOf< document_reference_item, 1, 0 >::Out items;
+    };
+
+    // C++ wrapper for effectivity_assignment
+    struct effectivity_assignment :  ObjectHelper<effectivity_assignment,1> { effectivity_assignment() : Object("effectivity_assignment") {}
+		Lazy< effectivity > assigned_effectivity;
+    };
+
+    // C++ wrapper for applied_effectivity_assignment
+    struct applied_effectivity_assignment : effectivity_assignment, ObjectHelper<applied_effectivity_assignment,1> { applied_effectivity_assignment() : Object("applied_effectivity_assignment") {}
+		ListOf< effectivity_item, 1, 0 >::Out items;
+    };
+
+    // C++ wrapper for event_occurrence_assignment
+    struct event_occurrence_assignment :  ObjectHelper<event_occurrence_assignment,2> { event_occurrence_assignment() : Object("event_occurrence_assignment") {}
+		Lazy< event_occurrence > assigned_event_occurrence;
+		Lazy< NotImplemented > role;
+    };
+
+    // C++ wrapper for applied_event_occurrence_assignment
+    struct applied_event_occurrence_assignment : event_occurrence_assignment, ObjectHelper<applied_event_occurrence_assignment,1> { applied_event_occurrence_assignment() : Object("applied_event_occurrence_assignment") {}
+		ListOf< event_occurrence_item, 1, 0 >::Out items;
+    };
+
+    // C++ wrapper for identification_assignment
+    struct identification_assignment :  ObjectHelper<identification_assignment,2> { identification_assignment() : Object("identification_assignment") {}
+		identifier::Out assigned_id;
+		Lazy< NotImplemented > role;
+    };
+
+    // C++ wrapper for external_identification_assignment
+    struct external_identification_assignment : identification_assignment, ObjectHelper<external_identification_assignment,1> { external_identification_assignment() : Object("external_identification_assignment") {}
+		Lazy< external_source > source;
+    };
+
+    // C++ wrapper for applied_external_identification_assignment
+    struct applied_external_identification_assignment : external_identification_assignment, ObjectHelper<applied_external_identification_assignment,1> { applied_external_identification_assignment() : Object("applied_external_identification_assignment") {}
+		ListOf< external_identification_item, 1, 0 >::Out items;
+    };
+
+    // C++ wrapper for group_assignment
+    struct group_assignment :  ObjectHelper<group_assignment,1> { group_assignment() : Object("group_assignment") {}
+		Lazy< group > assigned_group;
+    };
+
+    // C++ wrapper for applied_group_assignment
+    struct applied_group_assignment : group_assignment, ObjectHelper<applied_group_assignment,1> { applied_group_assignment() : Object("applied_group_assignment") {}
+		ListOf< groupable_item, 1, 0 >::Out items;
+    };
+
+    // C++ wrapper for applied_identification_assignment
+    struct applied_identification_assignment : identification_assignment, ObjectHelper<applied_identification_assignment,1> { applied_identification_assignment() : Object("applied_identification_assignment") {}
+		ListOf< identification_item, 1, 0 >::Out items;
+    };
+
+    // C++ wrapper for name_assignment
+    struct name_assignment :  ObjectHelper<name_assignment,1> { name_assignment() : Object("name_assignment") {}
+		label::Out assigned_name;
+    };
+
+    // C++ wrapper for applied_name_assignment
+    struct applied_name_assignment : name_assignment, ObjectHelper<applied_name_assignment,1> { applied_name_assignment() : Object("applied_name_assignment") {}
+		name_item::Out item;
+    };
+
+    // C++ wrapper for organization_assignment
+    struct organization_assignment :  ObjectHelper<organization_assignment,2> { organization_assignment() : Object("organization_assignment") {}
+		Lazy< NotImplemented > assigned_organization;
+		Lazy< NotImplemented > role;
+    };
+
+    // C++ wrapper for applied_organization_assignment
+    struct applied_organization_assignment : organization_assignment, ObjectHelper<applied_organization_assignment,1> { applied_organization_assignment() : Object("applied_organization_assignment") {}
+		ListOf< organization_item, 1, 0 >::Out items;
+    };
+
+    // C++ wrapper for organizational_project_assignment
+    struct organizational_project_assignment :  ObjectHelper<organizational_project_assignment,2> { organizational_project_assignment() : Object("organizational_project_assignment") {}
+		Lazy< NotImplemented > assigned_organizational_project;
+		Lazy< NotImplemented > role;
+    };
+
+    // C++ wrapper for applied_organizational_project_assignment
+    struct applied_organizational_project_assignment : organizational_project_assignment, ObjectHelper<applied_organizational_project_assignment,1> { applied_organizational_project_assignment() : Object("applied_organizational_project_assignment") {}
+		ListOf< project_item, 1, 0 >::Out items;
+    };
+
+    // C++ wrapper for person_and_organization_assignment
+    struct person_and_organization_assignment :  ObjectHelper<person_and_organization_assignment,2> { person_and_organization_assignment() : Object("person_and_organization_assignment") {}
+		Lazy< NotImplemented > assigned_person_and_organization;
+		Lazy< NotImplemented > role;
+    };
+
+    // C++ wrapper for applied_person_and_organization_assignment
+    struct applied_person_and_organization_assignment : person_and_organization_assignment, ObjectHelper<applied_person_and_organization_assignment,1> { applied_person_and_organization_assignment() : Object("applied_person_and_organization_assignment") {}
+		ListOf< person_and_organization_item, 1, 0 >::Out items;
+    };
+
+    // C++ wrapper for presented_item
+    struct presented_item :  ObjectHelper<presented_item,0> { presented_item() : Object("presented_item") {}
+
+    };
+
+    // C++ wrapper for applied_presented_item
+    struct applied_presented_item : presented_item, ObjectHelper<applied_presented_item,1> { applied_presented_item() : Object("applied_presented_item") {}
+		ListOf< presented_item_select, 1, 0 >::Out items;
+    };
+
+    // C++ wrapper for security_classification_assignment
+    struct security_classification_assignment :  ObjectHelper<security_classification_assignment,1> { security_classification_assignment() : Object("security_classification_assignment") {}
+		Lazy< NotImplemented > assigned_security_classification;
+    };
+
+    // C++ wrapper for applied_security_classification_assignment
+    struct applied_security_classification_assignment : security_classification_assignment, ObjectHelper<applied_security_classification_assignment,1> { applied_security_classification_assignment() : Object("applied_security_classification_assignment") {}
+		ListOf< security_classification_item, 1, 0 >::Out items;
+    };
+
+    // C++ wrapper for time_interval_assignment
+    struct time_interval_assignment :  ObjectHelper<time_interval_assignment,2> { time_interval_assignment() : Object("time_interval_assignment") {}
+		Lazy< time_interval > assigned_time_interval;
+		Lazy< NotImplemented > role;
+    };
+
+    // C++ wrapper for applied_time_interval_assignment
+    struct applied_time_interval_assignment : time_interval_assignment, ObjectHelper<applied_time_interval_assignment,1> { applied_time_interval_assignment() : Object("applied_time_interval_assignment") {}
+		ListOf< time_interval_item, 0, 0 >::Out items;
+    };
+
+    // C++ wrapper for applied_usage_right
+    struct applied_usage_right : applied_action_assignment, ObjectHelper<applied_usage_right,0> { applied_usage_right() : Object("applied_usage_right") {}
+
+    };
+
+    // C++ wrapper for area_in_set
+    struct area_in_set :  ObjectHelper<area_in_set,2> { area_in_set() : Object("area_in_set") {}
+		Lazy< presentation_area > area;
+		Lazy< presentation_set > in_set;
+    };
+
+    // C++ wrapper for area_measure_with_unit
+    struct area_measure_with_unit : measure_with_unit, ObjectHelper<area_measure_with_unit,0> { area_measure_with_unit() : Object("area_measure_with_unit") {}
+
+    };
+
+    // C++ wrapper for area_unit
+    struct area_unit : derived_unit, ObjectHelper<area_unit,0> { area_unit() : Object("area_unit") {}
+
+    };
+
+    // C++ wrapper for product_definition_relationship
+    struct product_definition_relationship :  ObjectHelper<product_definition_relationship,5> { product_definition_relationship() : Object("product_definition_relationship") {}
+		identifier::Out id;
+		label::Out name;
+		Maybe< text::Out > description;
+		Lazy< product_definition > relating_product_definition;
+		Lazy< product_definition > related_product_definition;
+    };
+
+    // C++ wrapper for product_definition_usage
+    struct product_definition_usage : product_definition_relationship, ObjectHelper<product_definition_usage,0> { product_definition_usage() : Object("product_definition_usage") {}
+
+    };
+
+    // C++ wrapper for assembly_component_usage
+    struct assembly_component_usage : product_definition_usage, ObjectHelper<assembly_component_usage,1> { assembly_component_usage() : Object("assembly_component_usage") {}
+		Maybe< identifier::Out > reference_designator;
+    };
+
+    // C++ wrapper for assigned_requirement
+    struct assigned_requirement : group_assignment, ObjectHelper<assigned_requirement,1> { assigned_requirement() : Object("assigned_requirement") {}
+		ListOf< Lazy< product_definition >, 1, 1 > items;
+    };
+
+    // C++ wrapper for compound_representation_item
+    struct compound_representation_item : representation_item, ObjectHelper<compound_representation_item,1> { compound_representation_item() : Object("compound_representation_item") {}
+		compound_item_definition::Out item_element;
+    };
+
+    // C++ wrapper for atomic_formula
+    struct atomic_formula : compound_representation_item, ObjectHelper<atomic_formula,0> { atomic_formula() : Object("atomic_formula") {}
+
+    };
+
+    // C++ wrapper for attribute_assertion
+    struct attribute_assertion :  ObjectHelper<attribute_assertion,0> { attribute_assertion() : Object("attribute_assertion") {}
+
+    };
+
+    // C++ wrapper for attribute_language_assignment
+    struct attribute_language_assignment : attribute_classification_assignment, ObjectHelper<attribute_language_assignment,1> { attribute_language_assignment() : Object("attribute_language_assignment") {}
+		ListOf< attribute_language_item, 1, 0 >::Out items;
+    };
+
+    // C++ wrapper for attribute_value_assignment
+    struct attribute_value_assignment :  ObjectHelper<attribute_value_assignment,3> { attribute_value_assignment() : Object("attribute_value_assignment") {}
+		label::Out attribute_name;
+		attribute_type::Out attribute_value;
+		Lazy< NotImplemented > role;
+    };
+
+    // C++ wrapper for auxiliary_geometric_representation_item
+    struct auxiliary_geometric_representation_item :  ObjectHelper<auxiliary_geometric_representation_item,0> { auxiliary_geometric_representation_item() : Object("auxiliary_geometric_representation_item") {}
+
+    };
+
+    // C++ wrapper for placement
+    struct placement : geometric_representation_item, ObjectHelper<placement,1> { placement() : Object("placement") {}
+		Lazy< cartesian_point > location;
+    };
+
+    // C++ wrapper for axis1_placement
+    struct axis1_placement : placement, ObjectHelper<axis1_placement,1> { axis1_placement() : Object("axis1_placement") {}
+		Maybe< Lazy< direction > > axis;
+    };
+
+    // C++ wrapper for axis2_placement_2d
+    struct axis2_placement_2d : placement, ObjectHelper<axis2_placement_2d,1> { axis2_placement_2d() : Object("axis2_placement_2d") {}
+		Maybe< Lazy< direction > > ref_direction;
+    };
+
+    // C++ wrapper for axis2_placement_3d
+    struct axis2_placement_3d : placement, ObjectHelper<axis2_placement_3d,2> { axis2_placement_3d() : Object("axis2_placement_3d") {}
+		Maybe< Lazy< direction > > axis;
+		Maybe< Lazy< direction > > ref_direction;
+    };
+
+    // C++ wrapper for curve
+    struct curve : geometric_representation_item, ObjectHelper<curve,0> { curve() : Object("curve") {}
+
+    };
+
+    // C++ wrapper for bounded_curve
+    struct bounded_curve : curve, ObjectHelper<bounded_curve,0> { bounded_curve() : Object("bounded_curve") {}
+
+    };
+
+    // C++ wrapper for b_spline_curve
+    struct b_spline_curve : bounded_curve, ObjectHelper<b_spline_curve,5> { b_spline_curve() : Object("b_spline_curve") {}
+		INTEGER::Out degree;
+		ListOf< Lazy< cartesian_point >, 2, 0 > control_points_list;
+		b_spline_curve_form::Out curve_form;
+		LOGICAL::Out closed_curve;
+		LOGICAL::Out self_intersect;
+    };
+
+    // C++ wrapper for b_spline_curve_with_knots
+    struct b_spline_curve_with_knots : b_spline_curve, ObjectHelper<b_spline_curve_with_knots,3> { b_spline_curve_with_knots() : Object("b_spline_curve_with_knots") {}
+		ListOf< INTEGER, 2, 0 >::Out knot_multiplicities;
+		ListOf< parameter_value, 2, 0 >::Out knots;
+		knot_type::Out knot_spec;
+    };
+
+    // C++ wrapper for surface
+    struct surface : geometric_representation_item, ObjectHelper<surface,0> { surface() : Object("surface") {}
+
+    };
+
+    // C++ wrapper for bounded_surface
+    struct bounded_surface : surface, ObjectHelper<bounded_surface,0> { bounded_surface() : Object("bounded_surface") {}
+
+    };
+
+    // C++ wrapper for b_spline_surface
+    struct b_spline_surface : bounded_surface, ObjectHelper<b_spline_surface,6> { b_spline_surface() : Object("b_spline_surface") {}
+		INTEGER::Out u_degree;
+		INTEGER::Out v_degree;
+		b_spline_surface_form::Out surface_form;
+		LOGICAL::Out u_closed;
+		LOGICAL::Out v_closed;
+		LOGICAL::Out self_intersect;
+    };
+
+    // C++ wrapper for b_spline_surface_with_knots
+    struct b_spline_surface_with_knots : b_spline_surface, ObjectHelper<b_spline_surface_with_knots,5> { b_spline_surface_with_knots() : Object("b_spline_surface_with_knots") {}
+		ListOf< INTEGER, 2, 0 >::Out u_multiplicities;
+		ListOf< INTEGER, 2, 0 >::Out v_multiplicities;
+		ListOf< parameter_value, 2, 0 >::Out u_knots;
+		ListOf< parameter_value, 2, 0 >::Out v_knots;
+		knot_type::Out knot_spec;
+    };
+
+    // C++ wrapper for product_definition
+    struct product_definition :  ObjectHelper<product_definition,4> { product_definition() : Object("product_definition") {}
+		identifier::Out id;
+		Maybe< text::Out > description;
+		Lazy< product_definition_formation > formation;
+		Lazy< product_definition_context > frame_of_reference;
+    };
+
+    // C++ wrapper for rule_software_definition
+    struct rule_software_definition : product_definition, ObjectHelper<rule_software_definition,0> { rule_software_definition() : Object("rule_software_definition") {}
+
+    };
+
+    // C++ wrapper for rule_definition
+    struct rule_definition : rule_software_definition, ObjectHelper<rule_definition,0> { rule_definition() : Object("rule_definition") {}
+
+    };
+
+    // C++ wrapper for back_chaining_rule
+    struct back_chaining_rule : rule_definition, ObjectHelper<back_chaining_rule,0> { back_chaining_rule() : Object("back_chaining_rule") {}
+
+    };
+
+    // C++ wrapper for back_chaining_rule_body
+    struct back_chaining_rule_body :  ObjectHelper<back_chaining_rule_body,0> { back_chaining_rule_body() : Object("back_chaining_rule_body") {}
+
+    };
+
+    // C++ wrapper for colour
+    struct colour :  ObjectHelper<colour,0> { colour() : Object("colour") {}
+
+    };
+
+    // C++ wrapper for background_colour
+    struct background_colour : colour, ObjectHelper<background_colour,1> { background_colour() : Object("background_colour") {}
+		area_or_view::Out presentation;
+    };
+
+    // C++ wrapper for beveled_sheet_representation
+    struct beveled_sheet_representation : shape_representation, ObjectHelper<beveled_sheet_representation,0> { beveled_sheet_representation() : Object("beveled_sheet_representation") {}
+
+    };
+
+    // C++ wrapper for bezier_curve
+    struct bezier_curve : b_spline_curve, ObjectHelper<bezier_curve,0> { bezier_curve() : Object("bezier_curve") {}
+
+    };
+
+    // C++ wrapper for bezier_surface
+    struct bezier_surface : b_spline_surface, ObjectHelper<bezier_surface,0> { bezier_surface() : Object("bezier_surface") {}
+
+    };
+
+    // C++ wrapper for generic_expression
+    struct generic_expression :  ObjectHelper<generic_expression,0> { generic_expression() : Object("generic_expression") {}
+
+    };
+
+    // C++ wrapper for binary_generic_expression
+    struct binary_generic_expression : generic_expression, ObjectHelper<binary_generic_expression,1> { binary_generic_expression() : Object("binary_generic_expression") {}
+		ListOf< Lazy< generic_expression >, 2, 2 > operands;
+    };
+
+    // C++ wrapper for binary_numeric_expression
+    struct binary_numeric_expression :  ObjectHelper<binary_numeric_expression,0> { binary_numeric_expression() : Object("binary_numeric_expression") {}
+
+    };
+
+    // C++ wrapper for binary_representation_item
+    struct binary_representation_item : representation_item, ObjectHelper<binary_representation_item,1> { binary_representation_item() : Object("binary_representation_item") {}
+		BINARY::Out binary_value;
+    };
+
+    // C++ wrapper for block
+    struct block : geometric_representation_item, ObjectHelper<block,4> { block() : Object("block") {}
+		Lazy< axis2_placement_3d > position;
+		positive_length_measure::Out x;
+		positive_length_measure::Out y;
+		positive_length_measure::Out z;
+    };
+
+    // C++ wrapper for expression
+    struct expression : generic_expression, ObjectHelper<expression,0> { expression() : Object("expression") {}
+
+    };
+
+    // C++ wrapper for boolean_expression
+    struct boolean_expression : expression, ObjectHelper<boolean_expression,0> { boolean_expression() : Object("boolean_expression") {}
+
+    };
+
+    // C++ wrapper for boolean_literal
+    struct boolean_literal :  ObjectHelper<boolean_literal,1> { boolean_literal() : Object("boolean_literal") {}
+		BOOLEAN::Out the_value;
+    };
+
+    // C++ wrapper for boolean_representation_item
+    struct boolean_representation_item :  ObjectHelper<boolean_representation_item,0> { boolean_representation_item() : Object("boolean_representation_item") {}
+
+    };
+
+    // C++ wrapper for boolean_result
+    struct boolean_result : geometric_representation_item, ObjectHelper<boolean_result,3> { boolean_result() : Object("boolean_result") {}
+		boolean_operator::Out operator_;
+		boolean_operand::Out first_operand;
+		boolean_operand::Out second_operand;
+    };
+
+    // C++ wrapper for composite_curve
+    struct composite_curve : bounded_curve, ObjectHelper<composite_curve,2> { composite_curve() : Object("composite_curve") {}
+		ListOf< Lazy< composite_curve_segment >, 1, 0 > segments;
+		LOGICAL::Out self_intersect;
+    };
+
+    // C++ wrapper for composite_curve_on_surface
+    struct composite_curve_on_surface : composite_curve, ObjectHelper<composite_curve_on_surface,0> { composite_curve_on_surface() : Object("composite_curve_on_surface") {}
+
+    };
+
+    // C++ wrapper for boundary_curve
+    struct boundary_curve : composite_curve_on_surface, ObjectHelper<boundary_curve,0> { boundary_curve() : Object("boundary_curve") {}
+
+    };
+
+    // C++ wrapper for bounded_pcurve
+    struct bounded_pcurve :  ObjectHelper<bounded_pcurve,0> { bounded_pcurve() : Object("bounded_pcurve") {}
+
+    };
+
+    // C++ wrapper for bounded_surface_curve
+    struct bounded_surface_curve :  ObjectHelper<bounded_surface_curve,0> { bounded_surface_curve() : Object("bounded_surface_curve") {}
+
+    };
+
+    // C++ wrapper for founded_item
+    struct founded_item :  ObjectHelper<founded_item,0> { founded_item() : Object("founded_item") {}
+
+    };
+
+    // C++ wrapper for box_domain
+    struct box_domain : founded_item, ObjectHelper<box_domain,4> { box_domain() : Object("box_domain") {}
+		Lazy< cartesian_point > corner;
+		positive_length_measure::Out xlength;
+		positive_length_measure::Out ylength;
+		positive_length_measure::Out zlength;
+    };
+
+    // C++ wrapper for half_space_solid
+    struct half_space_solid : geometric_representation_item, ObjectHelper<half_space_solid,2> { half_space_solid() : Object("half_space_solid") {}
+		Lazy< surface > base_surface;
+		BOOLEAN::Out agreement_flag;
+    };
+
+    // C++ wrapper for boxed_half_space
+    struct boxed_half_space : half_space_solid, ObjectHelper<boxed_half_space,1> { boxed_half_space() : Object("boxed_half_space") {}
+		Lazy< box_domain > enclosure;
+    };
+
+    // C++ wrapper for breakdown_context
+    struct breakdown_context : product_definition_relationship, ObjectHelper<breakdown_context,0> { breakdown_context() : Object("breakdown_context") {}
+
+    };
+
+    // C++ wrapper for breakdown_element_group_assignment
+    struct breakdown_element_group_assignment : group_assignment, ObjectHelper<breakdown_element_group_assignment,1> { breakdown_element_group_assignment() : Object("breakdown_element_group_assignment") {}
+		ListOf< product_definition_or_breakdown_element_usage, 1, 1 >::Out items;
+    };
+
+    // C++ wrapper for breakdown_element_realization
+    struct breakdown_element_realization :  ObjectHelper<breakdown_element_realization,0> { breakdown_element_realization() : Object("breakdown_element_realization") {}
+
+    };
+
+    // C++ wrapper for breakdown_element_usage
+    struct breakdown_element_usage : product_definition_relationship, ObjectHelper<breakdown_element_usage,0> { breakdown_element_usage() : Object("breakdown_element_usage") {}
+
+    };
+
+    // C++ wrapper for breakdown_of
+    struct breakdown_of : product_definition_relationship, ObjectHelper<breakdown_of,0> { breakdown_of() : Object("breakdown_of") {}
+
+    };
+
+    // C++ wrapper for solid_model
+    struct solid_model : geometric_representation_item, ObjectHelper<solid_model,0> { solid_model() : Object("solid_model") {}
+
+    };
+
+    // C++ wrapper for manifold_solid_brep
+    struct manifold_solid_brep : solid_model, ObjectHelper<manifold_solid_brep,1> { manifold_solid_brep() : Object("manifold_solid_brep") {}
+		Lazy< closed_shell > outer;
+    };
+
+    // C++ wrapper for brep_with_voids
+    struct brep_with_voids : manifold_solid_brep, ObjectHelper<brep_with_voids,1> { brep_with_voids() : Object("brep_with_voids") {}
+		ListOf< Lazy< oriented_closed_shell >, 1, 0 > voids;
+    };
+
+    // C++ wrapper for bytes_representation_item
+    struct bytes_representation_item : binary_representation_item, ObjectHelper<bytes_representation_item,0> { bytes_representation_item() : Object("bytes_representation_item") {}
+
+    };
+
+    // C++ wrapper for date
+    struct date :  ObjectHelper<date,1> { date() : Object("date") {}
+		year_number::Out year_component;
+    };
+
+    // C++ wrapper for calendar_date
+    struct calendar_date : date, ObjectHelper<calendar_date,2> { calendar_date() : Object("calendar_date") {}
+		day_in_month_number::Out day_component;
+		month_in_year_number::Out month_component;
+    };
+
+    // C++ wrapper for camera_image
+    struct camera_image : mapped_item, ObjectHelper<camera_image,0> { camera_image() : Object("camera_image") {}
+
+    };
+
+    // C++ wrapper for camera_image_3d_with_scale
+    struct camera_image_3d_with_scale : camera_image, ObjectHelper<camera_image_3d_with_scale,0> { camera_image_3d_with_scale() : Object("camera_image_3d_with_scale") {}
+
+    };
+
+    // C++ wrapper for camera_model
+    struct camera_model : geometric_representation_item, ObjectHelper<camera_model,0> { camera_model() : Object("camera_model") {}
+
+    };
+
+    // C++ wrapper for camera_model_d3
+    struct camera_model_d3 : camera_model, ObjectHelper<camera_model_d3,2> { camera_model_d3() : Object("camera_model_d3") {}
+		Lazy< axis2_placement_3d > view_reference_system;
+		Lazy< view_volume > perspective_of_volume;
+    };
+
+    // C++ wrapper for camera_model_d3_multi_clipping
+    struct camera_model_d3_multi_clipping : camera_model_d3, ObjectHelper<camera_model_d3_multi_clipping,1> { camera_model_d3_multi_clipping() : Object("camera_model_d3_multi_clipping") {}
+		ListOf< camera_model_d3_multi_clipping_interection_select, 1, 0 >::Out shape_clipping;
+    };
+
+    // C++ wrapper for camera_model_d3_multi_clipping_intersection
+    struct camera_model_d3_multi_clipping_intersection : geometric_representation_item, ObjectHelper<camera_model_d3_multi_clipping_intersection,1> { camera_model_d3_multi_clipping_intersection() : Object("camera_model_d3_multi_clipping_intersection") {}
+		ListOf< camera_model_d3_multi_clipping_interection_select, 2, 0 >::Out shape_clipping;
+    };
+
+    // C++ wrapper for camera_model_d3_multi_clipping_union
+    struct camera_model_d3_multi_clipping_union : geometric_representation_item, ObjectHelper<camera_model_d3_multi_clipping_union,1> { camera_model_d3_multi_clipping_union() : Object("camera_model_d3_multi_clipping_union") {}
+		ListOf< camera_model_d3_multi_clipping_union_select, 2, 0 >::Out shape_clipping;
+    };
+
+    // C++ wrapper for camera_model_d3_with_hlhsr
+    struct camera_model_d3_with_hlhsr : camera_model_d3, ObjectHelper<camera_model_d3_with_hlhsr,1> { camera_model_d3_with_hlhsr() : Object("camera_model_d3_with_hlhsr") {}
+		BOOLEAN::Out hidden_line_surface_removal;
+    };
+
+    // C++ wrapper for camera_model_with_light_sources
+    struct camera_model_with_light_sources : camera_model_d3, ObjectHelper<camera_model_with_light_sources,1> { camera_model_with_light_sources() : Object("camera_model_with_light_sources") {}
+		ListOf< Lazy< light_source >, 1, 0 > sources;
+    };
+
+    // C++ wrapper for representation_map
+    struct representation_map :  ObjectHelper<representation_map,2> { representation_map() : Object("representation_map") {}
+		Lazy< representation_item > mapping_origin;
+		Lazy< representation > mapped_representation;
+    };
+
+    // C++ wrapper for camera_usage
+    struct camera_usage : representation_map, ObjectHelper<camera_usage,0> { camera_usage() : Object("camera_usage") {}
+
+    };
+
+    // C++ wrapper for capacitance_measure_with_unit
+    struct capacitance_measure_with_unit : measure_with_unit, ObjectHelper<capacitance_measure_with_unit,0> { capacitance_measure_with_unit() : Object("capacitance_measure_with_unit") {}
+
+    };
+
+    // C++ wrapper for capacitance_unit
+    struct capacitance_unit : derived_unit, ObjectHelper<capacitance_unit,0> { capacitance_unit() : Object("capacitance_unit") {}
+
+    };
+
+    // C++ wrapper for point
+    struct point : geometric_representation_item, ObjectHelper<point,0> { point() : Object("point") {}
+
+    };
+
+    // C++ wrapper for cartesian_point
+    struct cartesian_point : point, ObjectHelper<cartesian_point,1> { cartesian_point() : Object("cartesian_point") {}
+		ListOf< length_measure, 1, 3 >::Out coordinates;
+    };
+
+    // C++ wrapper for cartesian_transformation_operator
+    struct cartesian_transformation_operator :  ObjectHelper<cartesian_transformation_operator,4> { cartesian_transformation_operator() : Object("cartesian_transformation_operator") {}
+		Maybe< Lazy< direction > > axis1;
+		Maybe< Lazy< direction > > axis2;
+		Lazy< cartesian_point > local_origin;
+		Maybe< REAL::Out > scale;
+    };
+
+    // C++ wrapper for cartesian_transformation_operator_2d
+    struct cartesian_transformation_operator_2d : cartesian_transformation_operator, ObjectHelper<cartesian_transformation_operator_2d,0> { cartesian_transformation_operator_2d() : Object("cartesian_transformation_operator_2d") {}
+
+    };
+
+    // C++ wrapper for cartesian_transformation_operator_3d
+    struct cartesian_transformation_operator_3d : cartesian_transformation_operator, ObjectHelper<cartesian_transformation_operator_3d,1> { cartesian_transformation_operator_3d() : Object("cartesian_transformation_operator_3d") {}
+		Maybe< Lazy< direction > > axis3;
+    };
+
+    // C++ wrapper for cc_design_approval
+    struct cc_design_approval : approval_assignment, ObjectHelper<cc_design_approval,1> { cc_design_approval() : Object("cc_design_approval") {}
+		ListOf< approved_item, 1, 0 >::Out items;
+    };
+
+    // C++ wrapper for cc_design_certification
+    struct cc_design_certification : certification_assignment, ObjectHelper<cc_design_certification,1> { cc_design_certification() : Object("cc_design_certification") {}
+		ListOf< certified_item, 1, 0 >::Out items;
+    };
+
+    // C++ wrapper for cc_design_contract
+    struct cc_design_contract : contract_assignment, ObjectHelper<cc_design_contract,1> { cc_design_contract() : Object("cc_design_contract") {}
+		ListOf< contracted_item, 1, 0 >::Out items;
+    };
+
+    // C++ wrapper for cc_design_date_and_time_assignment
+    struct cc_design_date_and_time_assignment : date_and_time_assignment, ObjectHelper<cc_design_date_and_time_assignment,1> { cc_design_date_and_time_assignment() : Object("cc_design_date_and_time_assignment") {}
+		ListOf< date_time_item, 1, 0 >::Out items;
+    };
+
+    // C++ wrapper for cc_design_person_and_organization_assignment
+    struct cc_design_person_and_organization_assignment : person_and_organization_assignment, ObjectHelper<cc_design_person_and_organization_assignment,1> { cc_design_person_and_organization_assignment() : Object("cc_design_person_and_organization_assignment") {}
+		ListOf< cc_person_organization_item, 1, 0 >::Out items;
+    };
+
+    // C++ wrapper for cc_design_security_classification
+    struct cc_design_security_classification : security_classification_assignment, ObjectHelper<cc_design_security_classification,1> { cc_design_security_classification() : Object("cc_design_security_classification") {}
+		ListOf< cc_classified_item, 1, 0 >::Out items;
+    };
+
+    // C++ wrapper for cc_design_specification_reference
+    struct cc_design_specification_reference : document_reference, ObjectHelper<cc_design_specification_reference,1> { cc_design_specification_reference() : Object("cc_design_specification_reference") {}
+		ListOf< cc_specified_item, 1, 0 >::Out items;
+    };
+
+    // C++ wrapper for celsius_temperature_measure_with_unit
+    struct celsius_temperature_measure_with_unit : measure_with_unit, ObjectHelper<celsius_temperature_measure_with_unit,0> { celsius_temperature_measure_with_unit() : Object("celsius_temperature_measure_with_unit") {}
+
+    };
+
+    // C++ wrapper for centre_of_symmetry
+    struct centre_of_symmetry : derived_shape_aspect, ObjectHelper<centre_of_symmetry,0> { centre_of_symmetry() : Object("centre_of_symmetry") {}
+
+    };
+
+    // C++ wrapper for change
+    struct change : action_assignment, ObjectHelper<change,1> { change() : Object("change") {}
+		ListOf< work_item, 1, 0 >::Out items;
+    };
+
+    // C++ wrapper for change_request
+    struct change_request : action_request_assignment, ObjectHelper<change_request,1> { change_request() : Object("change_request") {}
+		ListOf< change_request_item, 1, 0 >::Out items;
+    };
+
+    // C++ wrapper for character_glyph_style_outline
+    struct character_glyph_style_outline : founded_item, ObjectHelper<character_glyph_style_outline,1> { character_glyph_style_outline() : Object("character_glyph_style_outline") {}
+		Lazy< curve_style > outline_style;
+    };
+
+    // C++ wrapper for character_glyph_style_stroke
+    struct character_glyph_style_stroke : founded_item, ObjectHelper<character_glyph_style_stroke,1> { character_glyph_style_stroke() : Object("character_glyph_style_stroke") {}
+		Lazy< curve_style > stroke_style;
+    };
+
+    // C++ wrapper for symbol_representation
+    struct symbol_representation : representation, ObjectHelper<symbol_representation,0> { symbol_representation() : Object("symbol_representation") {}
+
+    };
+
+    // C++ wrapper for generic_character_glyph_symbol
+    struct generic_character_glyph_symbol : symbol_representation, ObjectHelper<generic_character_glyph_symbol,0> { generic_character_glyph_symbol() : Object("generic_character_glyph_symbol") {}
+
+    };
+
+    // C++ wrapper for character_glyph_symbol
+    struct character_glyph_symbol : generic_character_glyph_symbol, ObjectHelper<character_glyph_symbol,2> { character_glyph_symbol() : Object("character_glyph_symbol") {}
+		Lazy< planar_extent > character_box;
+		ratio_measure::Out baseline_ratio;
+    };
+
+    // C++ wrapper for character_glyph_symbol_outline
+    struct character_glyph_symbol_outline : character_glyph_symbol, ObjectHelper<character_glyph_symbol_outline,1> { character_glyph_symbol_outline() : Object("character_glyph_symbol_outline") {}
+		ListOf< Lazy< annotation_fill_area >, 1, 0 > outlines;
+    };
+
+    // C++ wrapper for character_glyph_symbol_stroke
+    struct character_glyph_symbol_stroke : character_glyph_symbol, ObjectHelper<character_glyph_symbol_stroke,1> { character_glyph_symbol_stroke() : Object("character_glyph_symbol_stroke") {}
+		ListOf< Lazy< curve >, 1, 0 > strokes;
+    };
+
+    // C++ wrapper for general_property
+    struct general_property :  ObjectHelper<general_property,3> { general_property() : Object("general_property") {}
+		identifier::Out id;
+		label::Out name;
+		Maybe< text::Out > description;
+    };
+
+    // C++ wrapper for characteristic_data_column_header
+    struct characteristic_data_column_header : general_property, ObjectHelper<characteristic_data_column_header,0> { characteristic_data_column_header() : Object("characteristic_data_column_header") {}
+
+    };
+
+    // C++ wrapper for general_property_relationship
+    struct general_property_relationship :  ObjectHelper<general_property_relationship,4> { general_property_relationship() : Object("general_property_relationship") {}
+		label::Out name;
+		Maybe< text::Out > description;
+		Lazy< general_property > relating_property;
+		Lazy< general_property > related_property;
+    };
+
+    // C++ wrapper for characteristic_data_column_header_link
+    struct characteristic_data_column_header_link : general_property_relationship, ObjectHelper<characteristic_data_column_header_link,0> { characteristic_data_column_header_link() : Object("characteristic_data_column_header_link") {}
+
+    };
+
+    // C++ wrapper for characteristic_data_table_header
+    struct characteristic_data_table_header : general_property, ObjectHelper<characteristic_data_table_header,0> { characteristic_data_table_header() : Object("characteristic_data_table_header") {}
+
+    };
+
+    // C++ wrapper for characteristic_data_table_header_decomposition
+    struct characteristic_data_table_header_decomposition : general_property_relationship, ObjectHelper<characteristic_data_table_header_decomposition,0> { characteristic_data_table_header_decomposition() : Object("characteristic_data_table_header_decomposition") {}
+
+    };
+
+    // C++ wrapper for group
+    struct group :  ObjectHelper<group,2> { group() : Object("group") {}
+		label::Out name;
+		Maybe< text::Out > description;
+    };
+
+    // C++ wrapper for characteristic_type
+    struct characteristic_type : group, ObjectHelper<characteristic_type,0> { characteristic_type() : Object("characteristic_type") {}
+
+    };
+
+    // C++ wrapper for characterized_class
+    struct characterized_class :  ObjectHelper<characterized_class,0> { characterized_class() : Object("characterized_class") {}
+
+    };
+
+    // C++ wrapper for characterized_object
+    struct characterized_object :  ObjectHelper<characterized_object,2> { characterized_object() : Object("characterized_object") {}
+		label::Out name;
+		Maybe< text::Out > description;
+    };
+
+    // C++ wrapper for conic
+    struct conic : curve, ObjectHelper<conic,1> { conic() : Object("conic") {}
+		axis2_placement::Out position;
+    };
+
+    // C++ wrapper for circle
+    struct circle : conic, ObjectHelper<circle,1> { circle() : Object("circle") {}
+		positive_length_measure::Out radius;
+    };
+
+    // C++ wrapper for circular_runout_tolerance
+    struct circular_runout_tolerance : geometric_tolerance_with_datum_reference, ObjectHelper<circular_runout_tolerance,0> { circular_runout_tolerance() : Object("circular_runout_tolerance") {}
+
+    };
+
+    // C++ wrapper for class_by_extension
+    struct class_by_extension : class_t, ObjectHelper<class_by_extension,0> { class_by_extension() : Object("class_by_extension") {}
+
+    };
+
+    // C++ wrapper for class_by_intension
+    struct class_by_intension : class_t, ObjectHelper<class_by_intension,0> { class_by_intension() : Object("class_by_intension") {}
+
+    };
+
+    // C++ wrapper for class_system
+    struct class_system : group, ObjectHelper<class_system,0> { class_system() : Object("class_system") {}
+
+    };
+
+    // C++ wrapper for effectivity_context_assignment
+    struct effectivity_context_assignment :  ObjectHelper<effectivity_context_assignment,2> { effectivity_context_assignment() : Object("effectivity_context_assignment") {}
+		Lazy< effectivity_assignment > assigned_effectivity_assignment;
+		Lazy< NotImplemented > role;
+    };
+
+    // C++ wrapper for class_usage_effectivity_context_assignment
+    struct class_usage_effectivity_context_assignment : effectivity_context_assignment, ObjectHelper<class_usage_effectivity_context_assignment,1> { class_usage_effectivity_context_assignment() : Object("class_usage_effectivity_context_assignment") {}
+		ListOf< class_usage_effectivity_context_item, 1, 0 >::Out items;
+    };
+
+    // C++ wrapper for topological_representation_item
+    struct topological_representation_item : representation_item, ObjectHelper<topological_representation_item,0> { topological_representation_item() : Object("topological_representation_item") {}
+
+    };
+
+    // C++ wrapper for connected_face_set
+    struct connected_face_set : topological_representation_item, ObjectHelper<connected_face_set,1> { connected_face_set() : Object("connected_face_set") {}
+		ListOf< Lazy< face >, 1, 0 > cfs_faces;
+    };
+
+    // C++ wrapper for closed_shell
+    struct closed_shell : connected_face_set, ObjectHelper<closed_shell,0> { closed_shell() : Object("closed_shell") {}
+
+    };
+
+    // C++ wrapper for coaxiality_tolerance
+    struct coaxiality_tolerance : geometric_tolerance_with_datum_reference, ObjectHelper<coaxiality_tolerance,0> { coaxiality_tolerance() : Object("coaxiality_tolerance") {}
+
+    };
+
+    // C++ wrapper for colour_specification
+    struct colour_specification : colour, ObjectHelper<colour_specification,1> { colour_specification() : Object("colour_specification") {}
+		label::Out name;
+    };
+
+    // C++ wrapper for colour_rgb
+    struct colour_rgb : colour_specification, ObjectHelper<colour_rgb,3> { colour_rgb() : Object("colour_rgb") {}
+		REAL::Out red;
+		REAL::Out green;
+		REAL::Out blue;
+    };
+
+    // C++ wrapper for common_datum
+    struct common_datum :  ObjectHelper<common_datum,0> { common_datum() : Object("common_datum") {}
+
+    };
+
+    // C++ wrapper for comparison_expression
+    struct comparison_expression :  ObjectHelper<comparison_expression,0> { comparison_expression() : Object("comparison_expression") {}
+
+    };
+
+    // C++ wrapper for complex_clause
+    struct complex_clause : compound_representation_item, ObjectHelper<complex_clause,0> { complex_clause() : Object("complex_clause") {}
+
+    };
+
+    // C++ wrapper for complex_conjunctive_clause
+    struct complex_conjunctive_clause : complex_clause, ObjectHelper<complex_conjunctive_clause,0> { complex_conjunctive_clause() : Object("complex_conjunctive_clause") {}
+
+    };
+
+    // C++ wrapper for complex_disjunctive_clause
+    struct complex_disjunctive_clause : complex_clause, ObjectHelper<complex_disjunctive_clause,0> { complex_disjunctive_clause() : Object("complex_disjunctive_clause") {}
+
+    };
+
+    // C++ wrapper for modified_solid
+    struct modified_solid : solid_model, ObjectHelper<modified_solid,2> { modified_solid() : Object("modified_solid") {}
+		text::Out rationale;
+		base_solid_select::Out base_solid;
+    };
+
+    // C++ wrapper for shelled_solid
+    struct shelled_solid : modified_solid, ObjectHelper<shelled_solid,2> { shelled_solid() : Object("shelled_solid") {}
+		ListOf< Lazy< face_surface >, 1, 0 > deleted_face_set;
+		length_measure::Out thickness;
+    };
+
+    // C++ wrapper for complex_shelled_solid
+    struct complex_shelled_solid : shelled_solid, ObjectHelper<complex_shelled_solid,1> { complex_shelled_solid() : Object("complex_shelled_solid") {}
+		ListOf< length_measure, 1, 0 >::Out thickness_list;
+    };
+
+    // C++ wrapper for composite_assembly_definition
+    struct composite_assembly_definition : product_definition, ObjectHelper<composite_assembly_definition,0> { composite_assembly_definition() : Object("composite_assembly_definition") {}
+
+    };
+
+    // C++ wrapper for composite_assembly_sequence_definition
+    struct composite_assembly_sequence_definition : product_definition, ObjectHelper<composite_assembly_sequence_definition,0> { composite_assembly_sequence_definition() : Object("composite_assembly_sequence_definition") {}
+
+    };
+
+    // C++ wrapper for laminate_table
+    struct laminate_table : product_definition, ObjectHelper<laminate_table,0> { laminate_table() : Object("laminate_table") {}
+
+    };
+
+    // C++ wrapper for part_laminate_table
+    struct part_laminate_table : laminate_table, ObjectHelper<part_laminate_table,0> { part_laminate_table() : Object("part_laminate_table") {}
+
+    };
+
+    // C++ wrapper for composite_assembly_table
+    struct composite_assembly_table : part_laminate_table, ObjectHelper<composite_assembly_table,0> { composite_assembly_table() : Object("composite_assembly_table") {}
+
+    };
+
+    // C++ wrapper for composite_curve_segment
+    struct composite_curve_segment : founded_item, ObjectHelper<composite_curve_segment,3> { composite_curve_segment() : Object("composite_curve_segment") {}
+		transition_code::Out transition;
+		BOOLEAN::Out same_sense;
+		Lazy< curve > parent_curve;
+    };
+
+    // C++ wrapper for material_designation
+    struct material_designation :  ObjectHelper<material_designation,2> { material_designation() : Object("material_designation") {}
+		label::Out name;
+		ListOf< characterized_definition, 1, 0 >::Out definitions;
+    };
+
+    // C++ wrapper for composite_material_designation
+    struct composite_material_designation : material_designation, ObjectHelper<composite_material_designation,0> { composite_material_designation() : Object("composite_material_designation") {}
+
+    };
+
+    // C++ wrapper for composite_shape_aspect
+    struct composite_shape_aspect : shape_aspect, ObjectHelper<composite_shape_aspect,0> { composite_shape_aspect() : Object("composite_shape_aspect") {}
+
+    };
+
+    // C++ wrapper for composite_sheet_representation
+    struct composite_sheet_representation : shape_representation, ObjectHelper<composite_sheet_representation,0> { composite_sheet_representation() : Object("composite_sheet_representation") {}
+
+    };
+
+    // C++ wrapper for composite_text
+    struct composite_text : geometric_representation_item, ObjectHelper<composite_text,1> { composite_text() : Object("composite_text") {}
+		ListOf< text_or_character, 2, 0 >::Out collected_text;
+    };
+
+    // C++ wrapper for composite_text_with_associated_curves
+    struct composite_text_with_associated_curves : composite_text, ObjectHelper<composite_text_with_associated_curves,1> { composite_text_with_associated_curves() : Object("composite_text_with_associated_curves") {}
+		ListOf< Lazy< curve >, 1, 0 > associated_curves;
+    };
+
+    // C++ wrapper for composite_text_with_blanking_box
+    struct composite_text_with_blanking_box : composite_text, ObjectHelper<composite_text_with_blanking_box,1> { composite_text_with_blanking_box() : Object("composite_text_with_blanking_box") {}
+		Lazy< planar_box > blanking;
+    };
+
+    // C++ wrapper for composite_text_with_delineation
+    struct composite_text_with_delineation : composite_text, ObjectHelper<composite_text_with_delineation,1> { composite_text_with_delineation() : Object("composite_text_with_delineation") {}
+		text_delineation::Out delineation;
+    };
+
+    // C++ wrapper for composite_text_with_extent
+    struct composite_text_with_extent : composite_text, ObjectHelper<composite_text_with_extent,1> { composite_text_with_extent() : Object("composite_text_with_extent") {}
+		Lazy< planar_extent > extent;
+    };
+
+    // C++ wrapper for compound_shape_representation
+    struct compound_shape_representation : shape_representation, ObjectHelper<compound_shape_representation,0> { compound_shape_representation() : Object("compound_shape_representation") {}
+
+    };
+
+    // C++ wrapper for concentricity_tolerance
+    struct concentricity_tolerance : geometric_tolerance_with_datum_reference, ObjectHelper<concentricity_tolerance,0> { concentricity_tolerance() : Object("concentricity_tolerance") {}
+
+    };
+
+    // C++ wrapper for concept_feature_relationship
+    struct concept_feature_relationship :  ObjectHelper<concept_feature_relationship,4> { concept_feature_relationship() : Object("concept_feature_relationship") {}
+		label::Out name;
+		Maybe< text::Out > description;
+		Lazy< product_concept_feature > relating_product_concept_feature;
+		Lazy< product_concept_feature > related_product_concept_feature;
+    };
+
+    // C++ wrapper for concept_feature_relationship_with_condition
+    struct concept_feature_relationship_with_condition : concept_feature_relationship, ObjectHelper<concept_feature_relationship_with_condition,1> { concept_feature_relationship_with_condition() : Object("concept_feature_relationship_with_condition") {}
+		Lazy< NotImplemented > conditional_operator;
+    };
+
+    // C++ wrapper for product_concept_feature
+    struct product_concept_feature :  ObjectHelper<product_concept_feature,3> { product_concept_feature() : Object("product_concept_feature") {}
+		identifier::Out id;
+		label::Out name;
+		Maybe< text::Out > description;
+    };
+
+    // C++ wrapper for conditional_concept_feature
+    struct conditional_concept_feature : product_concept_feature, ObjectHelper<conditional_concept_feature,1> { conditional_concept_feature() : Object("conditional_concept_feature") {}
+		Lazy< concept_feature_relationship_with_condition > condition;
+    };
+
+    // C++ wrapper for conductance_measure_with_unit
+    struct conductance_measure_with_unit : measure_with_unit, ObjectHelper<conductance_measure_with_unit,0> { conductance_measure_with_unit() : Object("conductance_measure_with_unit") {}
+
+    };
+
+    // C++ wrapper for conductance_unit
+    struct conductance_unit : derived_unit, ObjectHelper<conductance_unit,0> { conductance_unit() : Object("conductance_unit") {}
+
+    };
+
+    // C++ wrapper for configuration_item
+    struct configuration_item :  ObjectHelper<configuration_item,5> { configuration_item() : Object("configuration_item") {}
+		identifier::Out id;
+		label::Out name;
+		Maybe< text::Out > description;
+		Lazy< NotImplemented > item_concept;
+		Maybe< label::Out > purpose;
+    };
+
+    // C++ wrapper for configurable_item
+    struct configurable_item : configuration_item, ObjectHelper<configurable_item,1> { configurable_item() : Object("configurable_item") {}
+		ListOf< Lazy< NotImplemented >, 1, 0 > item_concept_feature;
+    };
+
+    // C++ wrapper for effectivity
+    struct effectivity :  ObjectHelper<effectivity,1> { effectivity() : Object("effectivity") {}
+		identifier::Out id;
+    };
+
+    // C++ wrapper for product_definition_effectivity
+    struct product_definition_effectivity : effectivity, ObjectHelper<product_definition_effectivity,1> { product_definition_effectivity() : Object("product_definition_effectivity") {}
+		Lazy< product_definition_relationship > usage;
+    };
+
+    // C++ wrapper for configuration_effectivity
+    struct configuration_effectivity : product_definition_effectivity, ObjectHelper<configuration_effectivity,1> { configuration_effectivity() : Object("configuration_effectivity") {}
+		Lazy< NotImplemented > configuration;
+    };
+
+    // C++ wrapper for configuration_item_relationship
+    struct configuration_item_relationship :  ObjectHelper<configuration_item_relationship,4> { configuration_item_relationship() : Object("configuration_item_relationship") {}
+		label::Out name;
+		Maybe< text::Out > description;
+		Lazy< configuration_item > relating_configuration_item;
+		Lazy< configuration_item > related_configuration_item;
+    };
+
+    // C++ wrapper for configuration_item_hierarchical_relationship
+    struct configuration_item_hierarchical_relationship : configuration_item_relationship, ObjectHelper<configuration_item_hierarchical_relationship,0> { configuration_item_hierarchical_relationship() : Object("configuration_item_hierarchical_relationship") {}
+
+    };
+
+    // C++ wrapper for configuration_item_revision_sequence
+    struct configuration_item_revision_sequence : configuration_item_relationship, ObjectHelper<configuration_item_revision_sequence,0> { configuration_item_revision_sequence() : Object("configuration_item_revision_sequence") {}
+
+    };
+
+    // C++ wrapper for configured_effectivity_assignment
+    struct configured_effectivity_assignment : effectivity_assignment, ObjectHelper<configured_effectivity_assignment,1> { configured_effectivity_assignment() : Object("configured_effectivity_assignment") {}
+		ListOf< configured_effectivity_item, 1, 0 >::Out items;
+    };
+
+    // C++ wrapper for configured_effectivity_context_assignment
+    struct configured_effectivity_context_assignment : effectivity_context_assignment, ObjectHelper<configured_effectivity_context_assignment,1> { configured_effectivity_context_assignment() : Object("configured_effectivity_context_assignment") {}
+		ListOf< configured_effectivity_context_item, 1, 0 >::Out items;
+    };
+
+    // C++ wrapper for conical_stepped_hole_transition
+    struct conical_stepped_hole_transition : geometric_representation_item, ObjectHelper<conical_stepped_hole_transition,3> { conical_stepped_hole_transition() : Object("conical_stepped_hole_transition") {}
+		positive_integer::Out transition_number;
+		plane_angle_measure::Out cone_apex_angle;
+		positive_length_measure::Out cone_base_radius;
+    };
+
+    // C++ wrapper for elementary_surface
+    struct elementary_surface : surface, ObjectHelper<elementary_surface,1> { elementary_surface() : Object("elementary_surface") {}
+		Lazy< axis2_placement_3d > position;
+    };
+
+    // C++ wrapper for conical_surface
+    struct conical_surface : elementary_surface, ObjectHelper<conical_surface,2> { conical_surface() : Object("conical_surface") {}
+		length_measure::Out radius;
+		plane_angle_measure::Out semi_angle;
+    };
+
+    // C++ wrapper for connected_edge_set
+    struct connected_edge_set : topological_representation_item, ObjectHelper<connected_edge_set,1> { connected_edge_set() : Object("connected_edge_set") {}
+		ListOf< Lazy< edge >, 1, 0 > ces_edges;
+    };
+
+    // C++ wrapper for connected_face_sub_set
+    struct connected_face_sub_set : connected_face_set, ObjectHelper<connected_face_sub_set,1> { connected_face_sub_set() : Object("connected_face_sub_set") {}
+		Lazy< connected_face_set > parent_face_set;
+    };
+
+    // C++ wrapper for constructive_geometry_representation
+    struct constructive_geometry_representation : representation, ObjectHelper<constructive_geometry_representation,0> { constructive_geometry_representation() : Object("constructive_geometry_representation") {}
+
+    };
+
+    // C++ wrapper for representation_relationship
+    struct representation_relationship :  ObjectHelper<representation_relationship,4> { representation_relationship() : Object("representation_relationship") {}
+		label::Out name;
+		Maybe< text::Out > description;
+		Lazy< representation > rep_1;
+		Lazy< representation > rep_2;
+    };
+
+    // C++ wrapper for constructive_geometry_representation_relationship
+    struct constructive_geometry_representation_relationship : representation_relationship, ObjectHelper<constructive_geometry_representation_relationship,0> { constructive_geometry_representation_relationship() : Object("constructive_geometry_representation_relationship") {}
+
+    };
+
+    // C++ wrapper for contact_ratio_representation
+    struct contact_ratio_representation : representation, ObjectHelper<contact_ratio_representation,0> { contact_ratio_representation() : Object("contact_ratio_representation") {}
+
+    };
+
+    // C++ wrapper for invisibility
+    struct invisibility :  ObjectHelper<invisibility,1> { invisibility() : Object("invisibility") {}
+		ListOf< invisible_item, 1, 0 >::Out invisible_items;
+    };
+
+    // C++ wrapper for context_dependent_invisibility
+    struct context_dependent_invisibility : invisibility, ObjectHelper<context_dependent_invisibility,1> { context_dependent_invisibility() : Object("context_dependent_invisibility") {}
+		invisibility_context::Out presentation_context;
+    };
+
+    // C++ wrapper for over_riding_styled_item
+    struct over_riding_styled_item : styled_item, ObjectHelper<over_riding_styled_item,1> { over_riding_styled_item() : Object("over_riding_styled_item") {}
+		Lazy< styled_item > over_ridden_style;
+    };
+
+    // C++ wrapper for context_dependent_over_riding_styled_item
+    struct context_dependent_over_riding_styled_item : over_riding_styled_item, ObjectHelper<context_dependent_over_riding_styled_item,1> { context_dependent_over_riding_styled_item() : Object("context_dependent_over_riding_styled_item") {}
+		ListOf< style_context_select, 1, 0 >::Out style_context;
+    };
+
+    // C++ wrapper for context_dependent_unit
+    struct context_dependent_unit : named_unit, ObjectHelper<context_dependent_unit,1> { context_dependent_unit() : Object("context_dependent_unit") {}
+		label::Out name;
+    };
+
+    // C++ wrapper for conversion_based_unit
+    struct conversion_based_unit : named_unit, ObjectHelper<conversion_based_unit,2> { conversion_based_unit() : Object("conversion_based_unit") {}
+		label::Out name;
+		Lazy< measure_with_unit > conversion_factor;
+    };
+
+    // C++ wrapper for csg_shape_representation
+    struct csg_shape_representation : shape_representation, ObjectHelper<csg_shape_representation,0> { csg_shape_representation() : Object("csg_shape_representation") {}
+
+    };
+
+    // C++ wrapper for csg_solid
+    struct csg_solid : solid_model, ObjectHelper<csg_solid,1> { csg_solid() : Object("csg_solid") {}
+		csg_select::Out tree_root_expression;
+    };
+
+    // C++ wrapper for currency
+    struct currency : context_dependent_unit, ObjectHelper<currency,0> { currency() : Object("currency") {}
+
+    };
+
+    // C++ wrapper for currency_measure_with_unit
+    struct currency_measure_with_unit : measure_with_unit, ObjectHelper<currency_measure_with_unit,0> { currency_measure_with_unit() : Object("currency_measure_with_unit") {}
+
+    };
+
+    // C++ wrapper for curve_bounded_surface
+    struct curve_bounded_surface : bounded_surface, ObjectHelper<curve_bounded_surface,3> { curve_bounded_surface() : Object("curve_bounded_surface") {}
+		Lazy< surface > basis_surface;
+		ListOf< Lazy< boundary_curve >, 1, 0 > boundaries;
+		BOOLEAN::Out implicit_outer;
+    };
+
+    // C++ wrapper for curve_dimension
+    struct curve_dimension : dimension_curve_directed_callout, ObjectHelper<curve_dimension,0> { curve_dimension() : Object("curve_dimension") {}
+
+    };
+
+    // C++ wrapper for curve_replica
+    struct curve_replica : curve, ObjectHelper<curve_replica,2> { curve_replica() : Object("curve_replica") {}
+		Lazy< curve > parent_curve;
+		Lazy< cartesian_transformation_operator > transformation;
+    };
+
+    // C++ wrapper for curve_style
+    struct curve_style : founded_item, ObjectHelper<curve_style,4> { curve_style() : Object("curve_style") {}
+		label::Out name;
+		curve_font_or_scaled_curve_font_select::Out curve_font;
+		size_select::Out curve_width;
+		Lazy< colour > curve_colour;
+    };
+
+    // C++ wrapper for curve_style_font
+    struct curve_style_font : founded_item, ObjectHelper<curve_style_font,2> { curve_style_font() : Object("curve_style_font") {}
+		label::Out name;
+		ListOf< Lazy< curve_style_font_pattern >, 1, 0 > pattern_list;
+    };
+
+    // C++ wrapper for curve_style_font_and_scaling
+    struct curve_style_font_and_scaling : founded_item, ObjectHelper<curve_style_font_and_scaling,3> { curve_style_font_and_scaling() : Object("curve_style_font_and_scaling") {}
+		label::Out name;
+		curve_style_font_select::Out curve_font;
+		REAL::Out curve_font_scaling;
+    };
+
+    // C++ wrapper for curve_style_font_pattern
+    struct curve_style_font_pattern : founded_item, ObjectHelper<curve_style_font_pattern,2> { curve_style_font_pattern() : Object("curve_style_font_pattern") {}
+		positive_length_measure::Out visible_segment_length;
+		positive_length_measure::Out invisible_segment_length;
+    };
+
+    // C++ wrapper for curve_swept_solid_shape_representation
+    struct curve_swept_solid_shape_representation : shape_representation, ObjectHelper<curve_swept_solid_shape_representation,0> { curve_swept_solid_shape_representation() : Object("curve_swept_solid_shape_representation") {}
+
+    };
+
+    // C++ wrapper for cylindrical_surface
+    struct cylindrical_surface : elementary_surface, ObjectHelper<cylindrical_surface,1> { cylindrical_surface() : Object("cylindrical_surface") {}
+		positive_length_measure::Out radius;
+    };
+
+    // C++ wrapper for cylindricity_tolerance
+    struct cylindricity_tolerance : geometric_tolerance, ObjectHelper<cylindricity_tolerance,0> { cylindricity_tolerance() : Object("cylindricity_tolerance") {}
+
+    };
+
+    // C++ wrapper for date_representation_item
+    struct date_representation_item :  ObjectHelper<date_representation_item,0> { date_representation_item() : Object("date_representation_item") {}
+
+    };
+
+    // C++ wrapper for date_time_representation_item
+    struct date_time_representation_item :  ObjectHelper<date_time_representation_item,0> { date_time_representation_item() : Object("date_time_representation_item") {}
+
+    };
+
+    // C++ wrapper for dated_effectivity
+    struct dated_effectivity : effectivity, ObjectHelper<dated_effectivity,2> { dated_effectivity() : Object("dated_effectivity") {}
+		Maybe< date_time_or_event_occurrence::Out > effectivity_end_date;
+		date_time_or_event_occurrence::Out effectivity_start_date;
+    };
+
+    // C++ wrapper for datum
+    struct datum : shape_aspect, ObjectHelper<datum,1> { datum() : Object("datum") {}
+		identifier::Out identification;
+    };
+
+    // C++ wrapper for datum_feature
+    struct datum_feature : shape_aspect, ObjectHelper<datum_feature,0> { datum_feature() : Object("datum_feature") {}
+
+    };
+
+    // C++ wrapper for datum_feature_callout
+    struct datum_feature_callout : draughting_callout, ObjectHelper<datum_feature_callout,0> { datum_feature_callout() : Object("datum_feature_callout") {}
+
+    };
+
+    // C++ wrapper for datum_reference
+    struct datum_reference :  ObjectHelper<datum_reference,2> { datum_reference() : Object("datum_reference") {}
+		INTEGER::Out precedence;
+		Lazy< datum > referenced_datum;
+    };
+
+    // C++ wrapper for datum_target
+    struct datum_target : shape_aspect, ObjectHelper<datum_target,1> { datum_target() : Object("datum_target") {}
+		identifier::Out target_id;
+    };
+
+    // C++ wrapper for datum_target_callout
+    struct datum_target_callout : draughting_callout, ObjectHelper<datum_target_callout,0> { datum_target_callout() : Object("datum_target_callout") {}
+
+    };
+
+    // C++ wrapper for default_tolerance_table
+    struct default_tolerance_table : representation, ObjectHelper<default_tolerance_table,0> { default_tolerance_table() : Object("default_tolerance_table") {}
+
+    };
+
+    // C++ wrapper for default_tolerance_table_cell
+    struct default_tolerance_table_cell : compound_representation_item, ObjectHelper<default_tolerance_table_cell,0> { default_tolerance_table_cell() : Object("default_tolerance_table_cell") {}
+
+    };
+
+    // C++ wrapper for defined_symbol
+    struct defined_symbol : geometric_representation_item, ObjectHelper<defined_symbol,2> { defined_symbol() : Object("defined_symbol") {}
+		defined_symbol_select::Out definition;
+		Lazy< symbol_target > target;
+    };
+
+    // C++ wrapper for definitional_representation
+    struct definitional_representation : representation, ObjectHelper<definitional_representation,0> { definitional_representation() : Object("definitional_representation") {}
+
+    };
+
+    // C++ wrapper for definitional_representation_relationship
+    struct definitional_representation_relationship : representation_relationship, ObjectHelper<definitional_representation_relationship,0> { definitional_representation_relationship() : Object("definitional_representation_relationship") {}
+
+    };
+
+    // C++ wrapper for definitional_representation_relationship_with_same_context
+    struct definitional_representation_relationship_with_same_context : definitional_representation_relationship, ObjectHelper<definitional_representation_relationship_with_same_context,0> { definitional_representation_relationship_with_same_context() : Object("definitional_representation_relationship_with_same_context") {}
+
+    };
+
+    // C++ wrapper for degenerate_pcurve
+    struct degenerate_pcurve : point, ObjectHelper<degenerate_pcurve,2> { degenerate_pcurve() : Object("degenerate_pcurve") {}
+		Lazy< surface > basis_surface;
+		Lazy< definitional_representation > reference_to_curve;
+    };
+
+    // C++ wrapper for toroidal_surface
+    struct toroidal_surface : elementary_surface, ObjectHelper<toroidal_surface,2> { toroidal_surface() : Object("toroidal_surface") {}
+		positive_length_measure::Out major_radius;
+		positive_length_measure::Out minor_radius;
+    };
+
+    // C++ wrapper for degenerate_toroidal_surface
+    struct degenerate_toroidal_surface : toroidal_surface, ObjectHelper<degenerate_toroidal_surface,1> { degenerate_toroidal_surface() : Object("degenerate_toroidal_surface") {}
+		BOOLEAN::Out select_outer;
+    };
+
+    // C++ wrapper for descriptive_representation_item
+    struct descriptive_representation_item : representation_item, ObjectHelper<descriptive_representation_item,1> { descriptive_representation_item() : Object("descriptive_representation_item") {}
+		text::Out description;
+    };
+
+    // C++ wrapper for product_definition_context
+    struct product_definition_context : application_context_element, ObjectHelper<product_definition_context,1> { product_definition_context() : Object("product_definition_context") {}
+		label::Out life_cycle_stage;
+    };
+
+    // C++ wrapper for design_context
+    struct design_context : product_definition_context, ObjectHelper<design_context,0> { design_context() : Object("design_context") {}
+
+    };
+
+    // C++ wrapper for design_make_from_relationship
+    struct design_make_from_relationship : product_definition_relationship, ObjectHelper<design_make_from_relationship,0> { design_make_from_relationship() : Object("design_make_from_relationship") {}
+
+    };
+
+    // C++ wrapper for diameter_dimension
+    struct diameter_dimension : dimension_curve_directed_callout, ObjectHelper<diameter_dimension,0> { diameter_dimension() : Object("diameter_dimension") {}
+
+    };
+
+    // C++ wrapper for ratio_measure_with_unit
+    struct ratio_measure_with_unit : measure_with_unit, ObjectHelper<ratio_measure_with_unit,0> { ratio_measure_with_unit() : Object("ratio_measure_with_unit") {}
+
+    };
+
+    // C++ wrapper for dielectric_constant_measure_with_unit
+    struct dielectric_constant_measure_with_unit : ratio_measure_with_unit, ObjectHelper<dielectric_constant_measure_with_unit,0> { dielectric_constant_measure_with_unit() : Object("dielectric_constant_measure_with_unit") {}
+
+    };
+
+    // C++ wrapper for dimension_callout
+    struct dimension_callout : draughting_callout, ObjectHelper<dimension_callout,0> { dimension_callout() : Object("dimension_callout") {}
+
+    };
+
+    // C++ wrapper for draughting_callout_relationship
+    struct draughting_callout_relationship :  ObjectHelper<draughting_callout_relationship,4> { draughting_callout_relationship() : Object("draughting_callout_relationship") {}
+		label::Out name;
+		text::Out description;
+		Lazy< draughting_callout > relating_draughting_callout;
+		Lazy< draughting_callout > related_draughting_callout;
+    };
+
+    // C++ wrapper for dimension_callout_component_relationship
+    struct dimension_callout_component_relationship : draughting_callout_relationship, ObjectHelper<dimension_callout_component_relationship,0> { dimension_callout_component_relationship() : Object("dimension_callout_component_relationship") {}
+
+    };
+
+    // C++ wrapper for dimension_callout_relationship
+    struct dimension_callout_relationship : draughting_callout_relationship, ObjectHelper<dimension_callout_relationship,0> { dimension_callout_relationship() : Object("dimension_callout_relationship") {}
+
+    };
+
+    // C++ wrapper for dimension_curve
+    struct dimension_curve : annotation_curve_occurrence, ObjectHelper<dimension_curve,0> { dimension_curve() : Object("dimension_curve") {}
+
+    };
+
+    // C++ wrapper for terminator_symbol
+    struct terminator_symbol : annotation_symbol_occurrence, ObjectHelper<terminator_symbol,1> { terminator_symbol() : Object("terminator_symbol") {}
+		Lazy< annotation_curve_occurrence > annotated_curve;
+    };
+
+    // C++ wrapper for dimension_curve_terminator
+    struct dimension_curve_terminator : terminator_symbol, ObjectHelper<dimension_curve_terminator,1> { dimension_curve_terminator() : Object("dimension_curve_terminator") {}
+		dimension_extent_usage::Out role;
+    };
+
+    // C++ wrapper for dimension_curve_terminator_to_projection_curve_associativity
+    struct dimension_curve_terminator_to_projection_curve_associativity : annotation_occurrence_associativity, ObjectHelper<dimension_curve_terminator_to_projection_curve_associativity,0> { dimension_curve_terminator_to_projection_curve_associativity() : Object("dimension_curve_terminator_to_projection_curve_associativity") {}
+
+    };
+
+    // C++ wrapper for dimension_pair
+    struct dimension_pair : draughting_callout_relationship, ObjectHelper<dimension_pair,0> { dimension_pair() : Object("dimension_pair") {}
+
+    };
+
+    // C++ wrapper for dimension_text_associativity
+    struct dimension_text_associativity :  ObjectHelper<dimension_text_associativity,0> { dimension_text_associativity() : Object("dimension_text_associativity") {}
+
+    };
+
+    // C++ wrapper for dimensional_location_with_path
+    struct dimensional_location_with_path : dimensional_location, ObjectHelper<dimensional_location_with_path,1> { dimensional_location_with_path() : Object("dimensional_location_with_path") {}
+		Lazy< shape_aspect > path;
+    };
+
+    // C++ wrapper for dimensional_size_with_path
+    struct dimensional_size_with_path : dimensional_size, ObjectHelper<dimensional_size_with_path,1> { dimensional_size_with_path() : Object("dimensional_size_with_path") {}
+		Lazy< shape_aspect > path;
+    };
+
+    // C++ wrapper for executed_action
+    struct executed_action : action, ObjectHelper<executed_action,0> { executed_action() : Object("executed_action") {}
+
+    };
+
+    // C++ wrapper for directed_action
+    struct directed_action : executed_action, ObjectHelper<directed_action,1> { directed_action() : Object("directed_action") {}
+		Lazy< NotImplemented > directive;
+    };
+
+    // C++ wrapper for directed_dimensional_location
+    struct directed_dimensional_location : dimensional_location, ObjectHelper<directed_dimensional_location,0> { directed_dimensional_location() : Object("directed_dimensional_location") {}
+
+    };
+
+    // C++ wrapper for direction
+    struct direction : geometric_representation_item, ObjectHelper<direction,1> { direction() : Object("direction") {}
+		ListOf< REAL, 2, 3 >::Out direction_ratios;
+    };
+
+    // C++ wrapper for document_file
+    struct document_file :  ObjectHelper<document_file,0> { document_file() : Object("document_file") {}
+
+    };
+
+    // C++ wrapper for document_identifier
+    struct document_identifier : group, ObjectHelper<document_identifier,0> { document_identifier() : Object("document_identifier") {}
+
+    };
+
+    // C++ wrapper for document_identifier_assignment
+    struct document_identifier_assignment : group_assignment, ObjectHelper<document_identifier_assignment,1> { document_identifier_assignment() : Object("document_identifier_assignment") {}
+		ListOf< document_identifier_assigned_item, 1, 0 >::Out items;
+    };
+
+    // C++ wrapper for document_product_association
+    struct document_product_association :  ObjectHelper<document_product_association,4> { document_product_association() : Object("document_product_association") {}
+		label::Out name;
+		Maybe< text::Out > description;
+		Lazy< NotImplemented > relating_document;
+		product_or_formation_or_definition::Out related_product;
+    };
+
+    // C++ wrapper for document_product_equivalence
+    struct document_product_equivalence : document_product_association, ObjectHelper<document_product_equivalence,0> { document_product_equivalence() : Object("document_product_equivalence") {}
+
+    };
+
+    // C++ wrapper for dose_equivalent_measure_with_unit
+    struct dose_equivalent_measure_with_unit : measure_with_unit, ObjectHelper<dose_equivalent_measure_with_unit,0> { dose_equivalent_measure_with_unit() : Object("dose_equivalent_measure_with_unit") {}
+
+    };
+
+    // C++ wrapper for dose_equivalent_unit
+    struct dose_equivalent_unit : derived_unit, ObjectHelper<dose_equivalent_unit,0> { dose_equivalent_unit() : Object("dose_equivalent_unit") {}
+
+    };
+
+    // C++ wrapper for double_offset_shelled_solid
+    struct double_offset_shelled_solid : shelled_solid, ObjectHelper<double_offset_shelled_solid,1> { double_offset_shelled_solid() : Object("double_offset_shelled_solid") {}
+		length_measure::Out thickness2;
+    };
+
+    // C++ wrapper for item_defined_transformation
+    struct item_defined_transformation :  ObjectHelper<item_defined_transformation,4> { item_defined_transformation() : Object("item_defined_transformation") {}
+		label::Out name;
+		Maybe< text::Out > description;
+		Lazy< representation_item > transform_item_1;
+		Lazy< representation_item > transform_item_2;
+    };
+
+    // C++ wrapper for transformation_with_derived_angle
+    struct transformation_with_derived_angle : item_defined_transformation, ObjectHelper<transformation_with_derived_angle,0> { transformation_with_derived_angle() : Object("transformation_with_derived_angle") {}
+
+    };
+
+    // C++ wrapper for draped_defined_transformation
+    struct draped_defined_transformation : transformation_with_derived_angle, ObjectHelper<draped_defined_transformation,0> { draped_defined_transformation() : Object("draped_defined_transformation") {}
+
+    };
+
+    // C++ wrapper for draughting_annotation_occurrence
+    struct draughting_annotation_occurrence : annotation_occurrence, ObjectHelper<draughting_annotation_occurrence,0> { draughting_annotation_occurrence() : Object("draughting_annotation_occurrence") {}
+
+    };
+
+    // C++ wrapper for draughting_elements
+    struct draughting_elements : draughting_callout, ObjectHelper<draughting_elements,0> { draughting_elements() : Object("draughting_elements") {}
+
+    };
+
+    // C++ wrapper for draughting_model
+    struct draughting_model : representation, ObjectHelper<draughting_model,0> { draughting_model() : Object("draughting_model") {}
+
+    };
+
+    // C++ wrapper for item_identified_representation_usage
+    struct item_identified_representation_usage :  ObjectHelper<item_identified_representation_usage,5> { item_identified_representation_usage() : Object("item_identified_representation_usage") {}
+		label::Out name;
+		Maybe< text::Out > description;
+		represented_definition::Out definition;
+		Lazy< representation > used_representation;
+		Lazy< representation_item > identified_item;
+    };
+
+    // C++ wrapper for draughting_model_item_association
+    struct draughting_model_item_association : item_identified_representation_usage, ObjectHelper<draughting_model_item_association,0> { draughting_model_item_association() : Object("draughting_model_item_association") {}
+
+    };
+
+    // C++ wrapper for pre_defined_colour
+    struct pre_defined_colour :  ObjectHelper<pre_defined_colour,0> { pre_defined_colour() : Object("pre_defined_colour") {}
+
+    };
+
+    // C++ wrapper for draughting_pre_defined_colour
+    struct draughting_pre_defined_colour : pre_defined_colour, ObjectHelper<draughting_pre_defined_colour,0> { draughting_pre_defined_colour() : Object("draughting_pre_defined_colour") {}
+
+    };
+
+    // C++ wrapper for pre_defined_item
+    struct pre_defined_item :  ObjectHelper<pre_defined_item,1> { pre_defined_item() : Object("pre_defined_item") {}
+		label::Out name;
+    };
+
+    // C++ wrapper for pre_defined_curve_font
+    struct pre_defined_curve_font : pre_defined_item, ObjectHelper<pre_defined_curve_font,0> { pre_defined_curve_font() : Object("pre_defined_curve_font") {}
+
+    };
+
+    // C++ wrapper for draughting_pre_defined_curve_font
+    struct draughting_pre_defined_curve_font : pre_defined_curve_font, ObjectHelper<draughting_pre_defined_curve_font,0> { draughting_pre_defined_curve_font() : Object("draughting_pre_defined_curve_font") {}
+
+    };
+
+    // C++ wrapper for pre_defined_text_font
+    struct pre_defined_text_font : pre_defined_item, ObjectHelper<pre_defined_text_font,0> { pre_defined_text_font() : Object("pre_defined_text_font") {}
+
+    };
+
+    // C++ wrapper for draughting_pre_defined_text_font
+    struct draughting_pre_defined_text_font : pre_defined_text_font, ObjectHelper<draughting_pre_defined_text_font,0> { draughting_pre_defined_text_font() : Object("draughting_pre_defined_text_font") {}
+
+    };
+
+    // C++ wrapper for draughting_subfigure_representation
+    struct draughting_subfigure_representation : symbol_representation, ObjectHelper<draughting_subfigure_representation,0> { draughting_subfigure_representation() : Object("draughting_subfigure_representation") {}
+
+    };
+
+    // C++ wrapper for draughting_symbol_representation
+    struct draughting_symbol_representation : symbol_representation, ObjectHelper<draughting_symbol_representation,0> { draughting_symbol_representation() : Object("draughting_symbol_representation") {}
+
+    };
+
+    // C++ wrapper for text_literal
+    struct text_literal : geometric_representation_item, ObjectHelper<text_literal,5> { text_literal() : Object("text_literal") {}
+		presentable_text::Out literal;
+		axis2_placement::Out placement;
+		text_alignment::Out alignment;
+		text_path::Out path;
+		font_select::Out font;
+    };
+
+    // C++ wrapper for text_literal_with_delineation
+    struct text_literal_with_delineation : text_literal, ObjectHelper<text_literal_with_delineation,1> { text_literal_with_delineation() : Object("text_literal_with_delineation") {}
+		text_delineation::Out delineation;
+    };
+
+    // C++ wrapper for draughting_text_literal_with_delineation
+    struct draughting_text_literal_with_delineation : text_literal_with_delineation, ObjectHelper<draughting_text_literal_with_delineation,0> { draughting_text_literal_with_delineation() : Object("draughting_text_literal_with_delineation") {}
+
+    };
+
+    // C++ wrapper for presentation_set
+    struct presentation_set :  ObjectHelper<presentation_set,0> { presentation_set() : Object("presentation_set") {}
+
+    };
+
+    // C++ wrapper for drawing_revision
+    struct drawing_revision : presentation_set, ObjectHelper<drawing_revision,3> { drawing_revision() : Object("drawing_revision") {}
+		identifier::Out revision_identifier;
+		Lazy< NotImplemented > drawing_identifier;
+		Maybe< text::Out > intended_scale;
+    };
+
+    // C++ wrapper for presentation_representation
+    struct presentation_representation : representation, ObjectHelper<presentation_representation,0> { presentation_representation() : Object("presentation_representation") {}
+
+    };
+
+    // C++ wrapper for presentation_area
+    struct presentation_area : presentation_representation, ObjectHelper<presentation_area,0> { presentation_area() : Object("presentation_area") {}
+
+    };
+
+    // C++ wrapper for drawing_sheet_revision
+    struct drawing_sheet_revision : presentation_area, ObjectHelper<drawing_sheet_revision,1> { drawing_sheet_revision() : Object("drawing_sheet_revision") {}
+		identifier::Out revision_identifier;
+    };
+
+    // C++ wrapper for drawing_sheet_revision_sequence
+    struct drawing_sheet_revision_sequence : representation_relationship, ObjectHelper<drawing_sheet_revision_sequence,0> { drawing_sheet_revision_sequence() : Object("drawing_sheet_revision_sequence") {}
+
+    };
+
+    // C++ wrapper for drawing_sheet_revision_usage
+    struct drawing_sheet_revision_usage : area_in_set, ObjectHelper<drawing_sheet_revision_usage,1> { drawing_sheet_revision_usage() : Object("drawing_sheet_revision_usage") {}
+		identifier::Out sheet_number;
+    };
+
+    // C++ wrapper for edge
+    struct edge : topological_representation_item, ObjectHelper<edge,2> { edge() : Object("edge") {}
+		Lazy< vertex > edge_start;
+		Lazy< vertex > edge_end;
+    };
+
+    // C++ wrapper for edge_based_wireframe_model
+    struct edge_based_wireframe_model : geometric_representation_item, ObjectHelper<edge_based_wireframe_model,1> { edge_based_wireframe_model() : Object("edge_based_wireframe_model") {}
+		ListOf< Lazy< connected_edge_set >, 1, 0 > ebwm_boundary;
+    };
+
+    // C++ wrapper for edge_based_wireframe_shape_representation
+    struct edge_based_wireframe_shape_representation : shape_representation, ObjectHelper<edge_based_wireframe_shape_representation,0> { edge_based_wireframe_shape_representation() : Object("edge_based_wireframe_shape_representation") {}
+
+    };
+
+    // C++ wrapper for edge_blended_solid
+    struct edge_blended_solid : modified_solid, ObjectHelper<edge_blended_solid,1> { edge_blended_solid() : Object("edge_blended_solid") {}
+		ListOf< Lazy< edge_curve >, 1, 0 > blended_edges;
+    };
+
+    // C++ wrapper for edge_curve
+    struct edge_curve :  ObjectHelper<edge_curve,2> { edge_curve() : Object("edge_curve") {}
+		Lazy< curve > edge_geometry;
+		BOOLEAN::Out same_sense;
+    };
+
+    // C++ wrapper for edge_loop
+    struct edge_loop :  ObjectHelper<edge_loop,0> { edge_loop() : Object("edge_loop") {}
+
+    };
+
+    // C++ wrapper for electric_charge_measure_with_unit
+    struct electric_charge_measure_with_unit : measure_with_unit, ObjectHelper<electric_charge_measure_with_unit,0> { electric_charge_measure_with_unit() : Object("electric_charge_measure_with_unit") {}
+
+    };
+
+    // C++ wrapper for electric_charge_unit
+    struct electric_charge_unit : derived_unit, ObjectHelper<electric_charge_unit,0> { electric_charge_unit() : Object("electric_charge_unit") {}
+
+    };
+
+    // C++ wrapper for electric_current_measure_with_unit
+    struct electric_current_measure_with_unit : measure_with_unit, ObjectHelper<electric_current_measure_with_unit,0> { electric_current_measure_with_unit() : Object("electric_current_measure_with_unit") {}
+
+    };
+
+    // C++ wrapper for electric_current_unit
+    struct electric_current_unit : named_unit, ObjectHelper<electric_current_unit,0> { electric_current_unit() : Object("electric_current_unit") {}
+
+    };
+
+    // C++ wrapper for electric_potential_measure_with_unit
+    struct electric_potential_measure_with_unit : measure_with_unit, ObjectHelper<electric_potential_measure_with_unit,0> { electric_potential_measure_with_unit() : Object("electric_potential_measure_with_unit") {}
+
+    };
+
+    // C++ wrapper for electric_potential_unit
+    struct electric_potential_unit : derived_unit, ObjectHelper<electric_potential_unit,0> { electric_potential_unit() : Object("electric_potential_unit") {}
+
+    };
+
+    // C++ wrapper for elementary_brep_shape_representation
+    struct elementary_brep_shape_representation : shape_representation, ObjectHelper<elementary_brep_shape_representation,0> { elementary_brep_shape_representation() : Object("elementary_brep_shape_representation") {}
+
+    };
+
+    // C++ wrapper for ellipse
+    struct ellipse : conic, ObjectHelper<ellipse,2> { ellipse() : Object("ellipse") {}
+		positive_length_measure::Out semi_axis_1;
+		positive_length_measure::Out semi_axis_2;
+    };
+
+    // C++ wrapper for energy_measure_with_unit
+    struct energy_measure_with_unit : measure_with_unit, ObjectHelper<energy_measure_with_unit,0> { energy_measure_with_unit() : Object("energy_measure_with_unit") {}
+
+    };
+
+    // C++ wrapper for energy_unit
+    struct energy_unit : derived_unit, ObjectHelper<energy_unit,0> { energy_unit() : Object("energy_unit") {}
+
+    };
+
+    // C++ wrapper for property_definition
+    struct property_definition :  ObjectHelper<property_definition,3> { property_definition() : Object("property_definition") {}
+		label::Out name;
+		Maybe< text::Out > description;
+		characterized_definition::Out definition;
+    };
+
+    // C++ wrapper for fact_type
+    struct fact_type : property_definition, ObjectHelper<fact_type,0> { fact_type() : Object("fact_type") {}
+
+    };
+
+    // C++ wrapper for entity_assertion
+    struct entity_assertion : fact_type, ObjectHelper<entity_assertion,0> { entity_assertion() : Object("entity_assertion") {}
+
+    };
+
+    // C++ wrapper for enum_reference_prefix
+    struct enum_reference_prefix : descriptive_representation_item, ObjectHelper<enum_reference_prefix,0> { enum_reference_prefix() : Object("enum_reference_prefix") {}
+
+    };
+
+    // C++ wrapper for evaluated_characteristic
+    struct evaluated_characteristic :  ObjectHelper<evaluated_characteristic,0> { evaluated_characteristic() : Object("evaluated_characteristic") {}
+
+    };
+
+    // C++ wrapper for evaluated_degenerate_pcurve
+    struct evaluated_degenerate_pcurve : degenerate_pcurve, ObjectHelper<evaluated_degenerate_pcurve,1> { evaluated_degenerate_pcurve() : Object("evaluated_degenerate_pcurve") {}
+		Lazy< cartesian_point > equivalent_point;
+    };
+
+    // C++ wrapper for evaluation_product_definition
+    struct evaluation_product_definition : product_definition, ObjectHelper<evaluation_product_definition,0> { evaluation_product_definition() : Object("evaluation_product_definition") {}
+
+    };
+
+    // C++ wrapper for event_occurrence
+    struct event_occurrence :  ObjectHelper<event_occurrence,3> { event_occurrence() : Object("event_occurrence") {}
+		identifier::Out id;
+		label::Out name;
+		Maybe< text::Out > description;
+    };
+
+    // C++ wrapper for product_concept_feature_category
+    struct product_concept_feature_category : group, ObjectHelper<product_concept_feature_category,0> { product_concept_feature_category() : Object("product_concept_feature_category") {}
+
+    };
+
+    // C++ wrapper for exclusive_product_concept_feature_category
+    struct exclusive_product_concept_feature_category : product_concept_feature_category, ObjectHelper<exclusive_product_concept_feature_category,0> { exclusive_product_concept_feature_category() : Object("exclusive_product_concept_feature_category") {}
+
+    };
+
+    // C++ wrapper for uncertainty_qualifier
+    struct uncertainty_qualifier :  ObjectHelper<uncertainty_qualifier,2> { uncertainty_qualifier() : Object("uncertainty_qualifier") {}
+		label::Out measure_name;
+		text::Out description;
+    };
+
+    // C++ wrapper for standard_uncertainty
+    struct standard_uncertainty : uncertainty_qualifier, ObjectHelper<standard_uncertainty,1> { standard_uncertainty() : Object("standard_uncertainty") {}
+		REAL::Out uncertainty_value;
+    };
+
+    // C++ wrapper for expanded_uncertainty
+    struct expanded_uncertainty : standard_uncertainty, ObjectHelper<expanded_uncertainty,1> { expanded_uncertainty() : Object("expanded_uncertainty") {}
+		REAL::Out coverage_factor;
+    };
+
+    // C++ wrapper for representation_item_relationship
+    struct representation_item_relationship :  ObjectHelper<representation_item_relationship,4> { representation_item_relationship() : Object("representation_item_relationship") {}
+		label::Out name;
+		Maybe< text::Out > description;
+		Lazy< representation_item > relating_representation_item;
+		Lazy< representation_item > related_representation_item;
+    };
+
+    // C++ wrapper for explicit_procedural_representation_item_relationship
+    struct explicit_procedural_representation_item_relationship : representation_item_relationship, ObjectHelper<explicit_procedural_representation_item_relationship,0> { explicit_procedural_representation_item_relationship() : Object("explicit_procedural_representation_item_relationship") {}
+
+    };
+
+    // C++ wrapper for explicit_procedural_geometric_representation_item_relationship
+    struct explicit_procedural_geometric_representation_item_relationship : explicit_procedural_representation_item_relationship, ObjectHelper<explicit_procedural_geometric_representation_item_relationship,0> { explicit_procedural_geometric_representation_item_relationship() : Object("explicit_procedural_geometric_representation_item_relationship") {}
+
+    };
+
+    // C++ wrapper for explicit_procedural_representation_relationship
+    struct explicit_procedural_representation_relationship : representation_relationship, ObjectHelper<explicit_procedural_representation_relationship,0> { explicit_procedural_representation_relationship() : Object("explicit_procedural_representation_relationship") {}
+
+    };
+
+    // C++ wrapper for explicit_procedural_shape_representation_relationship
+    struct explicit_procedural_shape_representation_relationship : explicit_procedural_representation_relationship, ObjectHelper<explicit_procedural_shape_representation_relationship,0> { explicit_procedural_shape_representation_relationship() : Object("explicit_procedural_shape_representation_relationship") {}
+
+    };
+
+    // C++ wrapper for expression_conversion_based_unit
+    struct expression_conversion_based_unit :  ObjectHelper<expression_conversion_based_unit,0> { expression_conversion_based_unit() : Object("expression_conversion_based_unit") {}
+
+    };
+
+    // C++ wrapper for extension
+    struct extension : derived_shape_aspect, ObjectHelper<extension,0> { extension() : Object("extension") {}
+
+    };
+
+    // C++ wrapper for extent
+    struct extent : characterized_object, ObjectHelper<extent,0> { extent() : Object("extent") {}
+
+    };
+
+    // C++ wrapper for external_source
+    struct external_source :  ObjectHelper<external_source,1> { external_source() : Object("external_source") {}
+		source_item::Out source_id;
+    };
+
+    // C++ wrapper for external_class_library
+    struct external_class_library : external_source, ObjectHelper<external_class_library,0> { external_class_library() : Object("external_class_library") {}
+
+    };
+
+    // C++ wrapper for externally_defined_class
+    struct externally_defined_class :  ObjectHelper<externally_defined_class,0> { externally_defined_class() : Object("externally_defined_class") {}
+
+    };
+
+    // C++ wrapper for externally_defined_colour
+    struct externally_defined_colour :  ObjectHelper<externally_defined_colour,0> { externally_defined_colour() : Object("externally_defined_colour") {}
+
+    };
+
+    // C++ wrapper for externally_defined_context_dependent_unit
+    struct externally_defined_context_dependent_unit :  ObjectHelper<externally_defined_context_dependent_unit,0> { externally_defined_context_dependent_unit() : Object("externally_defined_context_dependent_unit") {}
+
+    };
+
+    // C++ wrapper for externally_defined_conversion_based_unit
+    struct externally_defined_conversion_based_unit :  ObjectHelper<externally_defined_conversion_based_unit,0> { externally_defined_conversion_based_unit() : Object("externally_defined_conversion_based_unit") {}
+
+    };
+
+    // C++ wrapper for externally_defined_currency
+    struct externally_defined_currency :  ObjectHelper<externally_defined_currency,0> { externally_defined_currency() : Object("externally_defined_currency") {}
+
+    };
+
+    // C++ wrapper for externally_defined_item
+    struct externally_defined_item :  ObjectHelper<externally_defined_item,2> { externally_defined_item() : Object("externally_defined_item") {}
+		source_item::Out item_id;
+		Lazy< external_source > source;
+    };
+
+    // C++ wrapper for externally_defined_curve_font
+    struct externally_defined_curve_font : externally_defined_item, ObjectHelper<externally_defined_curve_font,0> { externally_defined_curve_font() : Object("externally_defined_curve_font") {}
+
+    };
+
+    // C++ wrapper for externally_defined_dimension_definition
+    struct externally_defined_dimension_definition :  ObjectHelper<externally_defined_dimension_definition,0> { externally_defined_dimension_definition() : Object("externally_defined_dimension_definition") {}
+
+    };
+
+    // C++ wrapper for externally_defined_general_property
+    struct externally_defined_general_property :  ObjectHelper<externally_defined_general_property,0> { externally_defined_general_property() : Object("externally_defined_general_property") {}
+
+    };
+
+    // C++ wrapper for externally_defined_hatch_style
+    struct externally_defined_hatch_style :  ObjectHelper<externally_defined_hatch_style,0> { externally_defined_hatch_style() : Object("externally_defined_hatch_style") {}
+
+    };
+
+    // C++ wrapper for externally_defined_marker
+    struct externally_defined_marker :  ObjectHelper<externally_defined_marker,0> { externally_defined_marker() : Object("externally_defined_marker") {}
+
+    };
+
+    // C++ wrapper for picture_representation_item
+    struct picture_representation_item : bytes_representation_item, ObjectHelper<picture_representation_item,0> { picture_representation_item() : Object("picture_representation_item") {}
+
+    };
+
+    // C++ wrapper for externally_defined_picture_representation_item
+    struct externally_defined_picture_representation_item : picture_representation_item, ObjectHelper<externally_defined_picture_representation_item,0> { externally_defined_picture_representation_item() : Object("externally_defined_picture_representation_item") {}
+
+    };
+
+    // C++ wrapper for externally_defined_representation_item
+    struct externally_defined_representation_item :  ObjectHelper<externally_defined_representation_item,0> { externally_defined_representation_item() : Object("externally_defined_representation_item") {}
+
+    };
+
+    // C++ wrapper for externally_defined_string
+    struct externally_defined_string : externally_defined_representation_item, ObjectHelper<externally_defined_string,0> { externally_defined_string() : Object("externally_defined_string") {}
+
+    };
+
+    // C++ wrapper for externally_defined_symbol
+    struct externally_defined_symbol : externally_defined_item, ObjectHelper<externally_defined_symbol,0> { externally_defined_symbol() : Object("externally_defined_symbol") {}
+
+    };
+
+    // C++ wrapper for externally_defined_terminator_symbol
+    struct externally_defined_terminator_symbol : externally_defined_symbol, ObjectHelper<externally_defined_terminator_symbol,0> { externally_defined_terminator_symbol() : Object("externally_defined_terminator_symbol") {}
+
+    };
+
+    // C++ wrapper for externally_defined_text_font
+    struct externally_defined_text_font : externally_defined_item, ObjectHelper<externally_defined_text_font,0> { externally_defined_text_font() : Object("externally_defined_text_font") {}
+
+    };
+
+    // C++ wrapper for externally_defined_tile
+    struct externally_defined_tile : externally_defined_item, ObjectHelper<externally_defined_tile,0> { externally_defined_tile() : Object("externally_defined_tile") {}
+
+    };
+
+    // C++ wrapper for externally_defined_tile_style
+    struct externally_defined_tile_style :  ObjectHelper<externally_defined_tile_style,0> { externally_defined_tile_style() : Object("externally_defined_tile_style") {}
+
+    };
+
+    // C++ wrapper for swept_area_solid
+    struct swept_area_solid : solid_model, ObjectHelper<swept_area_solid,1> { swept_area_solid() : Object("swept_area_solid") {}
+		Lazy< curve_bounded_surface > swept_area;
+    };
+
+    // C++ wrapper for extruded_area_solid
+    struct extruded_area_solid : swept_area_solid, ObjectHelper<extruded_area_solid,2> { extruded_area_solid() : Object("extruded_area_solid") {}
+		Lazy< direction > extruded_direction;
+		positive_length_measure::Out depth;
+    };
+
+    // C++ wrapper for swept_face_solid
+    struct swept_face_solid : solid_model, ObjectHelper<swept_face_solid,1> { swept_face_solid() : Object("swept_face_solid") {}
+		Lazy< face_surface > swept_face;
+    };
+
+    // C++ wrapper for extruded_face_solid
+    struct extruded_face_solid : swept_face_solid, ObjectHelper<extruded_face_solid,2> { extruded_face_solid() : Object("extruded_face_solid") {}
+		Lazy< direction > extruded_direction;
+		positive_length_measure::Out depth;
+    };
+
+    // C++ wrapper for extruded_face_solid_with_trim_conditions
+    struct extruded_face_solid_with_trim_conditions : extruded_face_solid, ObjectHelper<extruded_face_solid_with_trim_conditions,6> { extruded_face_solid_with_trim_conditions() : Object("extruded_face_solid_with_trim_conditions") {}
+		trim_condition_select::Out first_trim_condition;
+		trim_condition_select::Out second_trim_condition;
+		trim_intent::Out first_trim_intent;
+		trim_intent::Out second_trim_intent;
+		non_negative_length_measure::Out first_offset;
+		non_negative_length_measure::Out second_offset;
+    };
+
+    // C++ wrapper for extruded_face_solid_with_draft_angle
+    struct extruded_face_solid_with_draft_angle : extruded_face_solid_with_trim_conditions, ObjectHelper<extruded_face_solid_with_draft_angle,1> { extruded_face_solid_with_draft_angle() : Object("extruded_face_solid_with_draft_angle") {}
+		plane_angle_measure::Out draft_angle;
+    };
+
+    // C++ wrapper for extruded_face_solid_with_multiple_draft_angles
+    struct extruded_face_solid_with_multiple_draft_angles : extruded_face_solid_with_trim_conditions, ObjectHelper<extruded_face_solid_with_multiple_draft_angles,1> { extruded_face_solid_with_multiple_draft_angles() : Object("extruded_face_solid_with_multiple_draft_angles") {}
+		ListOf< plane_angle_measure, 2, 0 >::Out draft_angles;
+    };
+
+    // C++ wrapper for face
+    struct face : topological_representation_item, ObjectHelper<face,1> { face() : Object("face") {}
+		ListOf< Lazy< face_bound >, 1, 0 > bounds;
+    };
+
+    // C++ wrapper for face_based_surface_model
+    struct face_based_surface_model : geometric_representation_item, ObjectHelper<face_based_surface_model,1> { face_based_surface_model() : Object("face_based_surface_model") {}
+		ListOf< Lazy< connected_face_set >, 1, 0 > fbsm_faces;
+    };
+
+    // C++ wrapper for face_bound
+    struct face_bound : topological_representation_item, ObjectHelper<face_bound,2> { face_bound() : Object("face_bound") {}
+		Lazy< loop > bound;
+		BOOLEAN::Out orientation;
+    };
+
+    // C++ wrapper for face_outer_bound
+    struct face_outer_bound : face_bound, ObjectHelper<face_outer_bound,0> { face_outer_bound() : Object("face_outer_bound") {}
+
+    };
+
+    // C++ wrapper for faceted_brep
+    struct faceted_brep : manifold_solid_brep, ObjectHelper<faceted_brep,0> { faceted_brep() : Object("faceted_brep") {}
+
+    };
+
+    // C++ wrapper for faceted_brep_shape_representation
+    struct faceted_brep_shape_representation : shape_representation, ObjectHelper<faceted_brep_shape_representation,0> { faceted_brep_shape_representation() : Object("faceted_brep_shape_representation") {}
+
+    };
+
+    // C++ wrapper for fill_area_style
+    struct fill_area_style : founded_item, ObjectHelper<fill_area_style,2> { fill_area_style() : Object("fill_area_style") {}
+		label::Out name;
+		ListOf< fill_style_select, 1, 0 >::Out fill_styles;
+    };
+
+    // C++ wrapper for fill_area_style_hatching
+    struct fill_area_style_hatching : geometric_representation_item, ObjectHelper<fill_area_style_hatching,5> { fill_area_style_hatching() : Object("fill_area_style_hatching") {}
+		Lazy< curve_style > hatch_line_appearance;
+		Lazy< one_direction_repeat_factor > start_of_next_hatch_line;
+		Lazy< cartesian_point > point_of_reference_hatch_line;
+		Lazy< cartesian_point > pattern_start;
+		plane_angle_measure::Out hatch_line_angle;
+    };
+
+    // C++ wrapper for fill_area_style_tile_coloured_region
+    struct fill_area_style_tile_coloured_region : geometric_representation_item, ObjectHelper<fill_area_style_tile_coloured_region,2> { fill_area_style_tile_coloured_region() : Object("fill_area_style_tile_coloured_region") {}
+		curve_or_annotation_curve_occurrence::Out closed_curve;
+		Lazy< colour > region_colour;
+    };
+
+    // C++ wrapper for fill_area_style_tile_curve_with_style
+    struct fill_area_style_tile_curve_with_style : geometric_representation_item, ObjectHelper<fill_area_style_tile_curve_with_style,1> { fill_area_style_tile_curve_with_style() : Object("fill_area_style_tile_curve_with_style") {}
+		Lazy< annotation_curve_occurrence > styled_curve;
+    };
+
+    // C++ wrapper for fill_area_style_tile_symbol_with_style
+    struct fill_area_style_tile_symbol_with_style : geometric_representation_item, ObjectHelper<fill_area_style_tile_symbol_with_style,1> { fill_area_style_tile_symbol_with_style() : Object("fill_area_style_tile_symbol_with_style") {}
+		Lazy< annotation_symbol_occurrence > symbol;
+    };
+
+    // C++ wrapper for fill_area_style_tiles
+    struct fill_area_style_tiles : geometric_representation_item, ObjectHelper<fill_area_style_tiles,3> { fill_area_style_tiles() : Object("fill_area_style_tiles") {}
+		Lazy< two_direction_repeat_factor > tiling_pattern;
+		ListOf< fill_area_style_tile_shape_select, 1, 0 >::Out tiles;
+		positive_ratio_measure::Out tiling_scale;
+    };
+
+    // C++ wrapper for shape_representation_relationship
+    struct shape_representation_relationship : representation_relationship, ObjectHelper<shape_representation_relationship,0> { shape_representation_relationship() : Object("shape_representation_relationship") {}
+
+    };
+
+    // C++ wrapper for flat_pattern_ply_representation_relationship
+    struct flat_pattern_ply_representation_relationship : shape_representation_relationship, ObjectHelper<flat_pattern_ply_representation_relationship,0> { flat_pattern_ply_representation_relationship() : Object("flat_pattern_ply_representation_relationship") {}
+
+    };
+
+    // C++ wrapper for flatness_tolerance
+    struct flatness_tolerance : geometric_tolerance, ObjectHelper<flatness_tolerance,0> { flatness_tolerance() : Object("flatness_tolerance") {}
+
+    };
+
+    // C++ wrapper for force_measure_with_unit
+    struct force_measure_with_unit : measure_with_unit, ObjectHelper<force_measure_with_unit,0> { force_measure_with_unit() : Object("force_measure_with_unit") {}
+
+    };
+
+    // C++ wrapper for force_unit
+    struct force_unit : derived_unit, ObjectHelper<force_unit,0> { force_unit() : Object("force_unit") {}
+
+    };
+
+    // C++ wrapper for forward_chaining_rule
+    struct forward_chaining_rule : rule_definition, ObjectHelper<forward_chaining_rule,0> { forward_chaining_rule() : Object("forward_chaining_rule") {}
+
+    };
+
+    // C++ wrapper for forward_chaining_rule_premise
+    struct forward_chaining_rule_premise :  ObjectHelper<forward_chaining_rule_premise,0> { forward_chaining_rule_premise() : Object("forward_chaining_rule_premise") {}
+
+    };
+
+    // C++ wrapper for frequency_measure_with_unit
+    struct frequency_measure_with_unit : measure_with_unit, ObjectHelper<frequency_measure_with_unit,0> { frequency_measure_with_unit() : Object("frequency_measure_with_unit") {}
+
+    };
+
+    // C++ wrapper for frequency_unit
+    struct frequency_unit : derived_unit, ObjectHelper<frequency_unit,0> { frequency_unit() : Object("frequency_unit") {}
+
+    };
+
+    // C++ wrapper for func
+    struct func : compound_representation_item, ObjectHelper<func,0> { func() : Object("func") {}
+
+    };
+
+    // C++ wrapper for functional_breakdown_context
+    struct functional_breakdown_context : breakdown_context, ObjectHelper<functional_breakdown_context,0> { functional_breakdown_context() : Object("functional_breakdown_context") {}
+
+    };
+
+    // C++ wrapper for functional_element_usage
+    struct functional_element_usage : breakdown_element_usage, ObjectHelper<functional_element_usage,0> { functional_element_usage() : Object("functional_element_usage") {}
+
+    };
+
+    // C++ wrapper for general_material_property
+    struct general_material_property : general_property, ObjectHelper<general_material_property,0> { general_material_property() : Object("general_material_property") {}
+
+    };
+
+    // C++ wrapper for simple_generic_expression
+    struct simple_generic_expression : generic_expression, ObjectHelper<simple_generic_expression,0> { simple_generic_expression() : Object("simple_generic_expression") {}
+
+    };
+
+    // C++ wrapper for generic_literal
+    struct generic_literal : simple_generic_expression, ObjectHelper<generic_literal,0> { generic_literal() : Object("generic_literal") {}
+
+    };
+
+    // C++ wrapper for generic_variable
+    struct generic_variable : simple_generic_expression, ObjectHelper<generic_variable,0> { generic_variable() : Object("generic_variable") {}
+
+    };
+
+    // C++ wrapper for geometric_alignment
+    struct geometric_alignment : derived_shape_aspect, ObjectHelper<geometric_alignment,0> { geometric_alignment() : Object("geometric_alignment") {}
+
+    };
+
+    // C++ wrapper for geometric_set
+    struct geometric_set : geometric_representation_item, ObjectHelper<geometric_set,1> { geometric_set() : Object("geometric_set") {}
+		ListOf< geometric_set_select, 1, 0 >::Out elements;
+    };
+
+    // C++ wrapper for geometric_curve_set
+    struct geometric_curve_set : geometric_set, ObjectHelper<geometric_curve_set,0> { geometric_curve_set() : Object("geometric_curve_set") {}
+
+    };
+
+    // C++ wrapper for geometric_intersection
+    struct geometric_intersection : derived_shape_aspect, ObjectHelper<geometric_intersection,0> { geometric_intersection() : Object("geometric_intersection") {}
+
+    };
+
+    // C++ wrapper for geometric_item_specific_usage
+    struct geometric_item_specific_usage : item_identified_representation_usage, ObjectHelper<geometric_item_specific_usage,0> { geometric_item_specific_usage() : Object("geometric_item_specific_usage") {}
+
+    };
+
+    // C++ wrapper for geometric_model_element_relationship
+    struct geometric_model_element_relationship :  ObjectHelper<geometric_model_element_relationship,0> { geometric_model_element_relationship() : Object("geometric_model_element_relationship") {}
+
+    };
+
+    // C++ wrapper for representation_context
+    struct representation_context :  ObjectHelper<representation_context,2> { representation_context() : Object("representation_context") {}
+		identifier::Out context_identifier;
+		text::Out context_type;
+    };
+
+    // C++ wrapper for geometric_representation_context
+    struct geometric_representation_context : representation_context, ObjectHelper<geometric_representation_context,1> { geometric_representation_context() : Object("geometric_representation_context") {}
+		dimension_count::Out coordinate_space_dimension;
+    };
+
+    // C++ wrapper for geometric_tolerance_with_defined_unit
+    struct geometric_tolerance_with_defined_unit : geometric_tolerance, ObjectHelper<geometric_tolerance_with_defined_unit,1> { geometric_tolerance_with_defined_unit() : Object("geometric_tolerance_with_defined_unit") {}
+		Lazy< measure_with_unit > unit_size;
+    };
+
+    // C++ wrapper for geometrical_tolerance_callout
+    struct geometrical_tolerance_callout : draughting_callout, ObjectHelper<geometrical_tolerance_callout,0> { geometrical_tolerance_callout() : Object("geometrical_tolerance_callout") {}
+
+    };
+
+    // C++ wrapper for geometrically_bounded_2d_wireframe_representation
+    struct geometrically_bounded_2d_wireframe_representation : shape_representation, ObjectHelper<geometrically_bounded_2d_wireframe_representation,0> { geometrically_bounded_2d_wireframe_representation() : Object("geometrically_bounded_2d_wireframe_representation") {}
+
+    };
+
+    // C++ wrapper for geometrically_bounded_surface_shape_representation
+    struct geometrically_bounded_surface_shape_representation : shape_representation, ObjectHelper<geometrically_bounded_surface_shape_representation,0> { geometrically_bounded_surface_shape_representation() : Object("geometrically_bounded_surface_shape_representation") {}
+
+    };
+
+    // C++ wrapper for geometrically_bounded_wireframe_shape_representation
+    struct geometrically_bounded_wireframe_shape_representation : shape_representation, ObjectHelper<geometrically_bounded_wireframe_shape_representation,0> { geometrically_bounded_wireframe_shape_representation() : Object("geometrically_bounded_wireframe_shape_representation") {}
+
+    };
+
+    // C++ wrapper for global_assignment
+    struct global_assignment : representation_item_relationship, ObjectHelper<global_assignment,0> { global_assignment() : Object("global_assignment") {}
+
+    };
+
+    // C++ wrapper for global_uncertainty_assigned_context
+    struct global_uncertainty_assigned_context : representation_context, ObjectHelper<global_uncertainty_assigned_context,1> { global_uncertainty_assigned_context() : Object("global_uncertainty_assigned_context") {}
+		ListOf< Lazy< uncertainty_measure_with_unit >, 1, 0 > uncertainty;
+    };
+
+    // C++ wrapper for global_unit_assigned_context
+    struct global_unit_assigned_context : representation_context, ObjectHelper<global_unit_assigned_context,1> { global_unit_assigned_context() : Object("global_unit_assigned_context") {}
+		ListOf< unit, 1, 0 >::Out units;
+    };
+
+    // C++ wrapper for ground_fact
+    struct ground_fact : atomic_formula, ObjectHelper<ground_fact,0> { ground_fact() : Object("ground_fact") {}
+
+    };
+
+    // C++ wrapper for hardness_representation
+    struct hardness_representation : representation, ObjectHelper<hardness_representation,0> { hardness_representation() : Object("hardness_representation") {}
+
+    };
+
+    // C++ wrapper for hidden_element_over_riding_styled_item
+    struct hidden_element_over_riding_styled_item : context_dependent_over_riding_styled_item, ObjectHelper<hidden_element_over_riding_styled_item,0> { hidden_element_over_riding_styled_item() : Object("hidden_element_over_riding_styled_item") {}
+
+    };
+
+    // C++ wrapper for hyperbola
+    struct hyperbola : conic, ObjectHelper<hyperbola,2> { hyperbola() : Object("hyperbola") {}
+		positive_length_measure::Out semi_axis;
+		positive_length_measure::Out semi_imag_axis;
+    };
+
+    // C++ wrapper for illuminance_measure_with_unit
+    struct illuminance_measure_with_unit : measure_with_unit, ObjectHelper<illuminance_measure_with_unit,0> { illuminance_measure_with_unit() : Object("illuminance_measure_with_unit") {}
+
+    };
+
+    // C++ wrapper for illuminance_unit
+    struct illuminance_unit : derived_unit, ObjectHelper<illuminance_unit,0> { illuminance_unit() : Object("illuminance_unit") {}
+
+    };
+
+    // C++ wrapper for included_text_block
+    struct included_text_block : mapped_item, ObjectHelper<included_text_block,0> { included_text_block() : Object("included_text_block") {}
+
+    };
+
+    // C++ wrapper for inclusion_product_concept_feature
+    struct inclusion_product_concept_feature : conditional_concept_feature, ObjectHelper<inclusion_product_concept_feature,0> { inclusion_product_concept_feature() : Object("inclusion_product_concept_feature") {}
+
+    };
+
+    // C++ wrapper for user_selected_elements
+    struct user_selected_elements : representation_item, ObjectHelper<user_selected_elements,1> { user_selected_elements() : Object("user_selected_elements") {}
+		ListOf< Lazy< representation_item >, 1, 0 > picked_items;
+    };
+
+    // C++ wrapper for indirectly_selected_elements
+    struct indirectly_selected_elements : user_selected_elements, ObjectHelper<indirectly_selected_elements,1> { indirectly_selected_elements() : Object("indirectly_selected_elements") {}
+		ListOf< Lazy< representation_item >, 1, 0 > indirectly_picked_items;
+    };
+
+    // C++ wrapper for indirectly_selected_shape_elements
+    struct indirectly_selected_shape_elements :  ObjectHelper<indirectly_selected_shape_elements,0> { indirectly_selected_shape_elements() : Object("indirectly_selected_shape_elements") {}
+
+    };
+
+    // C++ wrapper for inductance_measure_with_unit
+    struct inductance_measure_with_unit : measure_with_unit, ObjectHelper<inductance_measure_with_unit,0> { inductance_measure_with_unit() : Object("inductance_measure_with_unit") {}
+
+    };
+
+    // C++ wrapper for inductance_unit
+    struct inductance_unit : derived_unit, ObjectHelper<inductance_unit,0> { inductance_unit() : Object("inductance_unit") {}
+
+    };
+
+    // C++ wrapper for information_right
+    struct information_right : action_method, ObjectHelper<information_right,0> { information_right() : Object("information_right") {}
+
+    };
+
+    // C++ wrapper for information_usage_right
+    struct information_usage_right : action_method, ObjectHelper<information_usage_right,0> { information_usage_right() : Object("information_usage_right") {}
+
+    };
+
+    // C++ wrapper for instance_usage_context_assignment
+    struct instance_usage_context_assignment : product_definition_context, ObjectHelper<instance_usage_context_assignment,1> { instance_usage_context_assignment() : Object("instance_usage_context_assignment") {}
+		ListOf< instance_usage_context_select, 1, 0 >::Out items;
+    };
+
+    // C++ wrapper for instanced_feature
+    struct instanced_feature :  ObjectHelper<instanced_feature,0> { instanced_feature() : Object("instanced_feature") {}
+
+    };
+
+    // C++ wrapper for literal_number
+    struct literal_number :  ObjectHelper<literal_number,1> { literal_number() : Object("literal_number") {}
+		NUMBER::Out the_value;
+    };
+
+    // C++ wrapper for int_literal
+    struct int_literal : literal_number, ObjectHelper<int_literal,0> { int_literal() : Object("int_literal") {}
+
+    };
+
+    // C++ wrapper for integer_representation_item
+    struct integer_representation_item :  ObjectHelper<integer_representation_item,0> { integer_representation_item() : Object("integer_representation_item") {}
+
+    };
+
+    // C++ wrapper for surface_curve
+    struct surface_curve : curve, ObjectHelper<surface_curve,3> { surface_curve() : Object("surface_curve") {}
+		Lazy< curve > curve_3d;
+		ListOf< pcurve_or_surface, 1, 2 >::Out associated_geometry;
+		preferred_surface_curve_representation::Out master_representation;
+    };
+
+    // C++ wrapper for intersection_curve
+    struct intersection_curve : surface_curve, ObjectHelper<intersection_curve,0> { intersection_curve() : Object("intersection_curve") {}
+
+    };
+
+    // C++ wrapper for interval_expression
+    struct interval_expression :  ObjectHelper<interval_expression,0> { interval_expression() : Object("interval_expression") {}
+
+    };
+
+    // C++ wrapper for iso4217_currency
+    struct iso4217_currency : currency, ObjectHelper<iso4217_currency,0> { iso4217_currency() : Object("iso4217_currency") {}
+
+    };
+
+    // C++ wrapper for known_source
+    struct known_source :  ObjectHelper<known_source,0> { known_source() : Object("known_source") {}
+
+    };
+
+    // C++ wrapper for laid_defined_transformation
+    struct laid_defined_transformation : transformation_with_derived_angle, ObjectHelper<laid_defined_transformation,0> { laid_defined_transformation() : Object("laid_defined_transformation") {}
+
+    };
+
+    // C++ wrapper for language
+    struct language : group, ObjectHelper<language,0> { language() : Object("language") {}
+
+    };
+
+    // C++ wrapper for leader_curve
+    struct leader_curve : annotation_curve_occurrence, ObjectHelper<leader_curve,0> { leader_curve() : Object("leader_curve") {}
+
+    };
+
+    // C++ wrapper for leader_directed_callout
+    struct leader_directed_callout : draughting_callout, ObjectHelper<leader_directed_callout,0> { leader_directed_callout() : Object("leader_directed_callout") {}
+
+    };
+
+    // C++ wrapper for leader_directed_dimension
+    struct leader_directed_dimension : leader_directed_callout, ObjectHelper<leader_directed_dimension,0> { leader_directed_dimension() : Object("leader_directed_dimension") {}
+
+    };
+
+    // C++ wrapper for leader_terminator
+    struct leader_terminator : terminator_symbol, ObjectHelper<leader_terminator,0> { leader_terminator() : Object("leader_terminator") {}
+
+    };
+
+    // C++ wrapper for length_measure_with_unit
+    struct length_measure_with_unit : measure_with_unit, ObjectHelper<length_measure_with_unit,0> { length_measure_with_unit() : Object("length_measure_with_unit") {}
+
+    };
+
+    // C++ wrapper for length_unit
+    struct length_unit : named_unit, ObjectHelper<length_unit,0> { length_unit() : Object("length_unit") {}
+
+    };
+
+    // C++ wrapper for light_source
+    struct light_source : geometric_representation_item, ObjectHelper<light_source,1> { light_source() : Object("light_source") {}
+		Lazy< colour > light_colour;
+    };
+
+    // C++ wrapper for light_source_ambient
+    struct light_source_ambient : light_source, ObjectHelper<light_source_ambient,0> { light_source_ambient() : Object("light_source_ambient") {}
+
+    };
+
+    // C++ wrapper for light_source_directional
+    struct light_source_directional : light_source, ObjectHelper<light_source_directional,1> { light_source_directional() : Object("light_source_directional") {}
+		Lazy< direction > orientation;
+    };
+
+    // C++ wrapper for light_source_positional
+    struct light_source_positional : light_source, ObjectHelper<light_source_positional,3> { light_source_positional() : Object("light_source_positional") {}
+		Lazy< cartesian_point > position;
+		REAL::Out constant_attenuation;
+		REAL::Out distance_attenuation;
+    };
+
+    // C++ wrapper for light_source_spot
+    struct light_source_spot : light_source, ObjectHelper<light_source_spot,6> { light_source_spot() : Object("light_source_spot") {}
+		Lazy< cartesian_point > position;
+		Lazy< direction > orientation;
+		REAL::Out concentration_exponent;
+		REAL::Out constant_attenuation;
+		REAL::Out distance_attenuation;
+		positive_plane_angle_measure::Out spread_angle;
+    };
+
+    // C++ wrapper for line
+    struct line : curve, ObjectHelper<line,2> { line() : Object("line") {}
+		Lazy< cartesian_point > pnt;
+		Lazy< vector > dir;
+    };
+
+    // C++ wrapper for line_profile_tolerance
+    struct line_profile_tolerance : geometric_tolerance, ObjectHelper<line_profile_tolerance,0> { line_profile_tolerance() : Object("line_profile_tolerance") {}
+
+    };
+
+    // C++ wrapper for linear_dimension
+    struct linear_dimension : dimension_curve_directed_callout, ObjectHelper<linear_dimension,0> { linear_dimension() : Object("linear_dimension") {}
+
+    };
+
+    // C++ wrapper for simple_clause
+    struct simple_clause : compound_representation_item, ObjectHelper<simple_clause,0> { simple_clause() : Object("simple_clause") {}
+
+    };
+
+    // C++ wrapper for literal_conjunction
+    struct literal_conjunction : simple_clause, ObjectHelper<literal_conjunction,0> { literal_conjunction() : Object("literal_conjunction") {}
+
+    };
+
+    // C++ wrapper for literal_disjunction
+    struct literal_disjunction : simple_clause, ObjectHelper<literal_disjunction,0> { literal_disjunction() : Object("literal_disjunction") {}
+
+    };
+
+    // C++ wrapper for logical_literal
+    struct logical_literal : generic_literal, ObjectHelper<logical_literal,1> { logical_literal() : Object("logical_literal") {}
+		LOGICAL::Out lit_value;
+    };
+
+    // C++ wrapper for logical_representation_item
+    struct logical_representation_item :  ObjectHelper<logical_representation_item,0> { logical_representation_item() : Object("logical_representation_item") {}
+
+    };
+
+    // C++ wrapper for loop
+    struct loop : topological_representation_item, ObjectHelper<loop,0> { loop() : Object("loop") {}
+
+    };
+
+    // C++ wrapper for loss_tangent_measure_with_unit
+    struct loss_tangent_measure_with_unit : ratio_measure_with_unit, ObjectHelper<loss_tangent_measure_with_unit,0> { loss_tangent_measure_with_unit() : Object("loss_tangent_measure_with_unit") {}
+
+    };
+
+    // C++ wrapper for lot_effectivity
+    struct lot_effectivity : effectivity, ObjectHelper<lot_effectivity,2> { lot_effectivity() : Object("lot_effectivity") {}
+		identifier::Out effectivity_lot_id;
+		Lazy< measure_with_unit > effectivity_lot_size;
+    };
+
+    // C++ wrapper for luminous_flux_measure_with_unit
+    struct luminous_flux_measure_with_unit : measure_with_unit, ObjectHelper<luminous_flux_measure_with_unit,0> { luminous_flux_measure_with_unit() : Object("luminous_flux_measure_with_unit") {}
+
+    };
+
+    // C++ wrapper for luminous_flux_unit
+    struct luminous_flux_unit : named_unit, ObjectHelper<luminous_flux_unit,0> { luminous_flux_unit() : Object("luminous_flux_unit") {}
+
+    };
+
+    // C++ wrapper for luminous_intensity_measure_with_unit
+    struct luminous_intensity_measure_with_unit : measure_with_unit, ObjectHelper<luminous_intensity_measure_with_unit,0> { luminous_intensity_measure_with_unit() : Object("luminous_intensity_measure_with_unit") {}
+
+    };
+
+    // C++ wrapper for luminous_intensity_unit
+    struct luminous_intensity_unit : named_unit, ObjectHelper<luminous_intensity_unit,0> { luminous_intensity_unit() : Object("luminous_intensity_unit") {}
+
+    };
+
+    // C++ wrapper for magnetic_flux_density_measure_with_unit
+    struct magnetic_flux_density_measure_with_unit : measure_with_unit, ObjectHelper<magnetic_flux_density_measure_with_unit,0> { magnetic_flux_density_measure_with_unit() : Object("magnetic_flux_density_measure_with_unit") {}
+
+    };
+
+    // C++ wrapper for magnetic_flux_density_unit
+    struct magnetic_flux_density_unit : derived_unit, ObjectHelper<magnetic_flux_density_unit,0> { magnetic_flux_density_unit() : Object("magnetic_flux_density_unit") {}
+
+    };
+
+    // C++ wrapper for magnetic_flux_measure_with_unit
+    struct magnetic_flux_measure_with_unit : measure_with_unit, ObjectHelper<magnetic_flux_measure_with_unit,0> { magnetic_flux_measure_with_unit() : Object("magnetic_flux_measure_with_unit") {}
+
+    };
+
+    // C++ wrapper for magnetic_flux_unit
+    struct magnetic_flux_unit : derived_unit, ObjectHelper<magnetic_flux_unit,0> { magnetic_flux_unit() : Object("magnetic_flux_unit") {}
+
+    };
+
+    // C++ wrapper for make_from_usage_option
+    struct make_from_usage_option : product_definition_usage, ObjectHelper<make_from_usage_option,3> { make_from_usage_option() : Object("make_from_usage_option") {}
+		INTEGER::Out ranking;
+		text::Out ranking_rationale;
+		Lazy< measure_with_unit > quantity;
+    };
+
+    // C++ wrapper for manifold_subsurface_shape_representation
+    struct manifold_subsurface_shape_representation : shape_representation, ObjectHelper<manifold_subsurface_shape_representation,0> { manifold_subsurface_shape_representation() : Object("manifold_subsurface_shape_representation") {}
+
+    };
+
+    // C++ wrapper for manifold_surface_shape_representation
+    struct manifold_surface_shape_representation : shape_representation, ObjectHelper<manifold_surface_shape_representation,0> { manifold_surface_shape_representation() : Object("manifold_surface_shape_representation") {}
+
+    };
+
+    // C++ wrapper for mass_measure_with_unit
+    struct mass_measure_with_unit : measure_with_unit, ObjectHelper<mass_measure_with_unit,0> { mass_measure_with_unit() : Object("mass_measure_with_unit") {}
+
+    };
+
+    // C++ wrapper for mass_unit
+    struct mass_unit : named_unit, ObjectHelper<mass_unit,0> { mass_unit() : Object("mass_unit") {}
+
+    };
+
+    // C++ wrapper for material_property
+    struct material_property : property_definition, ObjectHelper<material_property,0> { material_property() : Object("material_property") {}
+
+    };
+
+    // C++ wrapper for property_definition_representation
+    struct property_definition_representation :  ObjectHelper<property_definition_representation,2> { property_definition_representation() : Object("property_definition_representation") {}
+		represented_definition::Out definition;
+		Lazy< representation > used_representation;
+    };
+
+    // C++ wrapper for material_property_representation
+    struct material_property_representation : property_definition_representation, ObjectHelper<material_property_representation,1> { material_property_representation() : Object("material_property_representation") {}
+		Lazy< NotImplemented > dependent_environment;
+    };
+
+    // C++ wrapper for measure_representation_item
+    struct measure_representation_item :  ObjectHelper<measure_representation_item,0> { measure_representation_item() : Object("measure_representation_item") {}
+
+    };
+
+    // C++ wrapper for product_context
+    struct product_context : application_context_element, ObjectHelper<product_context,1> { product_context() : Object("product_context") {}
+		label::Out discipline_type;
+    };
+
+    // C++ wrapper for mechanical_context
+    struct mechanical_context : product_context, ObjectHelper<mechanical_context,0> { mechanical_context() : Object("mechanical_context") {}
+
+    };
+
+    // C++ wrapper for mechanical_design_and_draughting_relationship
+    struct mechanical_design_and_draughting_relationship : definitional_representation_relationship_with_same_context, ObjectHelper<mechanical_design_and_draughting_relationship,0> { mechanical_design_and_draughting_relationship() : Object("mechanical_design_and_draughting_relationship") {}
+
+    };
+
+    // C++ wrapper for mechanical_design_geometric_presentation_area
+    struct mechanical_design_geometric_presentation_area : presentation_area, ObjectHelper<mechanical_design_geometric_presentation_area,0> { mechanical_design_geometric_presentation_area() : Object("mechanical_design_geometric_presentation_area") {}
+
+    };
+
+    // C++ wrapper for mechanical_design_geometric_presentation_representation
+    struct mechanical_design_geometric_presentation_representation : representation, ObjectHelper<mechanical_design_geometric_presentation_representation,0> { mechanical_design_geometric_presentation_representation() : Object("mechanical_design_geometric_presentation_representation") {}
+
+    };
+
+    // C++ wrapper for mechanical_design_presentation_representation_with_draughting
+    struct mechanical_design_presentation_representation_with_draughting : representation, ObjectHelper<mechanical_design_presentation_representation_with_draughting,0> { mechanical_design_presentation_representation_with_draughting() : Object("mechanical_design_presentation_representation_with_draughting") {}
+
+    };
+
+    // C++ wrapper for mechanical_design_shaded_presentation_area
+    struct mechanical_design_shaded_presentation_area : presentation_area, ObjectHelper<mechanical_design_shaded_presentation_area,0> { mechanical_design_shaded_presentation_area() : Object("mechanical_design_shaded_presentation_area") {}
+
+    };
+
+    // C++ wrapper for mechanical_design_shaded_presentation_representation
+    struct mechanical_design_shaded_presentation_representation : representation, ObjectHelper<mechanical_design_shaded_presentation_representation,0> { mechanical_design_shaded_presentation_representation() : Object("mechanical_design_shaded_presentation_representation") {}
+
+    };
+
+    // C++ wrapper for min_and_major_ply_orientation_basis
+    struct min_and_major_ply_orientation_basis :  ObjectHelper<min_and_major_ply_orientation_basis,0> { min_and_major_ply_orientation_basis() : Object("min_and_major_ply_orientation_basis") {}
+
+    };
+
+    // C++ wrapper for modified_geometric_tolerance
+    struct modified_geometric_tolerance : geometric_tolerance, ObjectHelper<modified_geometric_tolerance,1> { modified_geometric_tolerance() : Object("modified_geometric_tolerance") {}
+		limit_condition::Out modifier;
+    };
+
+    // C++ wrapper for modified_solid_with_placed_configuration
+    struct modified_solid_with_placed_configuration : modified_solid, ObjectHelper<modified_solid_with_placed_configuration,1> { modified_solid_with_placed_configuration() : Object("modified_solid_with_placed_configuration") {}
+		Lazy< axis2_placement_3d > placing;
+    };
+
+    // C++ wrapper for moments_of_inertia_representation
+    struct moments_of_inertia_representation : representation, ObjectHelper<moments_of_inertia_representation,0> { moments_of_inertia_representation() : Object("moments_of_inertia_representation") {}
+
+    };
+
+    // C++ wrapper for multi_language_attribute_assignment
+    struct multi_language_attribute_assignment : attribute_value_assignment, ObjectHelper<multi_language_attribute_assignment,1> { multi_language_attribute_assignment() : Object("multi_language_attribute_assignment") {}
+		ListOf< multi_language_attribute_item, 1, 0 >::Out items;
+    };
+
+    // C++ wrapper for multiple_arity_boolean_expression
+    struct multiple_arity_boolean_expression :  ObjectHelper<multiple_arity_boolean_expression,0> { multiple_arity_boolean_expression() : Object("multiple_arity_boolean_expression") {}
+
+    };
+
+    // C++ wrapper for multiple_arity_generic_expression
+    struct multiple_arity_generic_expression : generic_expression, ObjectHelper<multiple_arity_generic_expression,1> { multiple_arity_generic_expression() : Object("multiple_arity_generic_expression") {}
+		ListOf< Lazy< generic_expression >, 2, 0 > operands;
+    };
+
+    // C++ wrapper for multiple_arity_numeric_expression
+    struct multiple_arity_numeric_expression :  ObjectHelper<multiple_arity_numeric_expression,0> { multiple_arity_numeric_expression() : Object("multiple_arity_numeric_expression") {}
+
+    };
+
+    // C++ wrapper for next_assembly_usage_occurrence
+    struct next_assembly_usage_occurrence : assembly_component_usage, ObjectHelper<next_assembly_usage_occurrence,0> { next_assembly_usage_occurrence() : Object("next_assembly_usage_occurrence") {}
+
+    };
+
+    // C++ wrapper for non_manifold_surface_shape_representation
+    struct non_manifold_surface_shape_representation : shape_representation, ObjectHelper<non_manifold_surface_shape_representation,0> { non_manifold_surface_shape_representation() : Object("non_manifold_surface_shape_representation") {}
+
+    };
+
+    // C++ wrapper for null_representation_item
+    struct null_representation_item : representation_item, ObjectHelper<null_representation_item,0> { null_representation_item() : Object("null_representation_item") {}
+
+    };
+
+    // C++ wrapper for numeric_expression
+    struct numeric_expression : expression, ObjectHelper<numeric_expression,0> { numeric_expression() : Object("numeric_expression") {}
+
+    };
+
+    // C++ wrapper for offset_curve_2d
+    struct offset_curve_2d : curve, ObjectHelper<offset_curve_2d,3> { offset_curve_2d() : Object("offset_curve_2d") {}
+		Lazy< curve > basis_curve;
+		length_measure::Out distance;
+		LOGICAL::Out self_intersect;
+    };
+
+    // C++ wrapper for offset_curve_3d
+    struct offset_curve_3d : curve, ObjectHelper<offset_curve_3d,4> { offset_curve_3d() : Object("offset_curve_3d") {}
+		Lazy< curve > basis_curve;
+		length_measure::Out distance;
+		LOGICAL::Out self_intersect;
+		Lazy< direction > ref_direction;
+    };
+
+    // C++ wrapper for offset_surface
+    struct offset_surface : surface, ObjectHelper<offset_surface,3> { offset_surface() : Object("offset_surface") {}
+		Lazy< surface > basis_surface;
+		length_measure::Out distance;
+		LOGICAL::Out self_intersect;
+    };
+
+    // C++ wrapper for one_direction_repeat_factor
+    struct one_direction_repeat_factor : geometric_representation_item, ObjectHelper<one_direction_repeat_factor,1> { one_direction_repeat_factor() : Object("one_direction_repeat_factor") {}
+		Lazy< vector > repeat_factor;
+    };
+
+    // C++ wrapper for open_shell
+    struct open_shell : connected_face_set, ObjectHelper<open_shell,0> { open_shell() : Object("open_shell") {}
+
+    };
+
+    // C++ wrapper for ordinal_date
+    struct ordinal_date : date, ObjectHelper<ordinal_date,1> { ordinal_date() : Object("ordinal_date") {}
+		day_in_year_number::Out day_component;
+    };
+
+    // C++ wrapper for projection_directed_callout
+    struct projection_directed_callout : draughting_callout, ObjectHelper<projection_directed_callout,0> { projection_directed_callout() : Object("projection_directed_callout") {}
+
+    };
+
+    // C++ wrapper for ordinate_dimension
+    struct ordinate_dimension : projection_directed_callout, ObjectHelper<ordinate_dimension,0> { ordinate_dimension() : Object("ordinate_dimension") {}
+
+    };
+
+    // C++ wrapper for organizational_address
+    struct organizational_address : address, ObjectHelper<organizational_address,2> { organizational_address() : Object("organizational_address") {}
+		ListOf< Lazy< NotImplemented >, 1, 0 > organizations;
+		Maybe< text::Out > description;
+    };
+
+    // C++ wrapper for oriented_closed_shell
+    struct oriented_closed_shell : closed_shell, ObjectHelper<oriented_closed_shell,2> { oriented_closed_shell() : Object("oriented_closed_shell") {}
+		Lazy< closed_shell > closed_shell_element;
+		BOOLEAN::Out orientation;
+    };
+
+    // C++ wrapper for oriented_edge
+    struct oriented_edge : edge, ObjectHelper<oriented_edge,2> { oriented_edge() : Object("oriented_edge") {}
+		Lazy< edge > edge_element;
+		BOOLEAN::Out orientation;
+    };
+
+    // C++ wrapper for oriented_face
+    struct oriented_face : face, ObjectHelper<oriented_face,2> { oriented_face() : Object("oriented_face") {}
+		Lazy< face > face_element;
+		BOOLEAN::Out orientation;
+    };
+
+    // C++ wrapper for oriented_open_shell
+    struct oriented_open_shell : open_shell, ObjectHelper<oriented_open_shell,2> { oriented_open_shell() : Object("oriented_open_shell") {}
+		Lazy< open_shell > open_shell_element;
+		BOOLEAN::Out orientation;
+    };
+
+    // C++ wrapper for path
+    struct path : topological_representation_item, ObjectHelper<path,1> { path() : Object("path") {}
+		ListOf< Lazy< oriented_edge >, 1, 0 > edge_list;
+    };
+
+    // C++ wrapper for oriented_path
+    struct oriented_path : path, ObjectHelper<oriented_path,2> { oriented_path() : Object("oriented_path") {}
+		Lazy< path > path_element;
+		BOOLEAN::Out orientation;
+    };
+
+    // C++ wrapper for oriented_surface
+    struct oriented_surface : surface, ObjectHelper<oriented_surface,1> { oriented_surface() : Object("oriented_surface") {}
+		BOOLEAN::Out orientation;
+    };
+
+    // C++ wrapper for outer_boundary_curve
+    struct outer_boundary_curve : boundary_curve, ObjectHelper<outer_boundary_curve,0> { outer_boundary_curve() : Object("outer_boundary_curve") {}
+
+    };
+
+    // C++ wrapper for package_product_concept_feature
+    struct package_product_concept_feature : product_concept_feature, ObjectHelper<package_product_concept_feature,0> { package_product_concept_feature() : Object("package_product_concept_feature") {}
+
+    };
+
+    // C++ wrapper for parabola
+    struct parabola : conic, ObjectHelper<parabola,1> { parabola() : Object("parabola") {}
+		length_measure::Out focal_dist;
+    };
+
+    // C++ wrapper for parallel_offset
+    struct parallel_offset : derived_shape_aspect, ObjectHelper<parallel_offset,1> { parallel_offset() : Object("parallel_offset") {}
+		Lazy< measure_with_unit > offset;
+    };
+
+    // C++ wrapper for parallelism_tolerance
+    struct parallelism_tolerance : geometric_tolerance_with_datum_reference, ObjectHelper<parallelism_tolerance,0> { parallelism_tolerance() : Object("parallelism_tolerance") {}
+
+    };
+
+    // C++ wrapper for parametric_representation_context
+    struct parametric_representation_context : representation_context, ObjectHelper<parametric_representation_context,0> { parametric_representation_context() : Object("parametric_representation_context") {}
+
+    };
+
+    // C++ wrapper for partial_document_with_structured_text_representation_assignment
+    struct partial_document_with_structured_text_representation_assignment :  ObjectHelper<partial_document_with_structured_text_representation_assignment,0> { partial_document_with_structured_text_representation_assignment() : Object("partial_document_with_structured_text_representation_assignment") {}
+
+    };
+
+    // C++ wrapper for pcurve
+    struct pcurve : curve, ObjectHelper<pcurve,2> { pcurve() : Object("pcurve") {}
+		Lazy< surface > basis_surface;
+		Lazy< definitional_representation > reference_to_curve;
+    };
+
+    // C++ wrapper for percentage_laminate_definition
+    struct percentage_laminate_definition : product_definition, ObjectHelper<percentage_laminate_definition,0> { percentage_laminate_definition() : Object("percentage_laminate_definition") {}
+
+    };
+
+    // C++ wrapper for zone_structural_makeup
+    struct zone_structural_makeup : laminate_table, ObjectHelper<zone_structural_makeup,0> { zone_structural_makeup() : Object("zone_structural_makeup") {}
+
+    };
+
+    // C++ wrapper for percentage_laminate_table
+    struct percentage_laminate_table : zone_structural_makeup, ObjectHelper<percentage_laminate_table,0> { percentage_laminate_table() : Object("percentage_laminate_table") {}
+
+    };
+
+    // C++ wrapper for percentage_ply_definition
+    struct percentage_ply_definition : product_definition, ObjectHelper<percentage_ply_definition,0> { percentage_ply_definition() : Object("percentage_ply_definition") {}
+
+    };
+
+    // C++ wrapper for perpendicular_to
+    struct perpendicular_to : derived_shape_aspect, ObjectHelper<perpendicular_to,0> { perpendicular_to() : Object("perpendicular_to") {}
+
+    };
+
+    // C++ wrapper for perpendicularity_tolerance
+    struct perpendicularity_tolerance : geometric_tolerance_with_datum_reference, ObjectHelper<perpendicularity_tolerance,0> { perpendicularity_tolerance() : Object("perpendicularity_tolerance") {}
+
+    };
+
+    // C++ wrapper for person_and_organization_address
+    struct person_and_organization_address :  ObjectHelper<person_and_organization_address,0> { person_and_organization_address() : Object("person_and_organization_address") {}
+
+    };
+
+    // C++ wrapper for personal_address
+    struct personal_address : address, ObjectHelper<personal_address,2> { personal_address() : Object("personal_address") {}
+		ListOf< Lazy< NotImplemented >, 1, 0 > people;
+		Maybe< text::Out > description;
+    };
+
+    // C++ wrapper for physical_breakdown_context
+    struct physical_breakdown_context : breakdown_context, ObjectHelper<physical_breakdown_context,0> { physical_breakdown_context() : Object("physical_breakdown_context") {}
+
+    };
+
+    // C++ wrapper for physical_element_usage
+    struct physical_element_usage : breakdown_element_usage, ObjectHelper<physical_element_usage,0> { physical_element_usage() : Object("physical_element_usage") {}
+
+    };
+
+    // C++ wrapper for presentation_view
+    struct presentation_view : presentation_representation, ObjectHelper<presentation_view,0> { presentation_view() : Object("presentation_view") {}
+
+    };
+
+    // C++ wrapper for picture_representation
+    struct picture_representation : presentation_view, ObjectHelper<picture_representation,0> { picture_representation() : Object("picture_representation") {}
+
+    };
+
+    // C++ wrapper for placed_datum_target_feature
+    struct placed_datum_target_feature : datum_target, ObjectHelper<placed_datum_target_feature,0> { placed_datum_target_feature() : Object("placed_datum_target_feature") {}
+
+    };
+
+    // C++ wrapper for placed_feature
+    struct placed_feature : shape_aspect, ObjectHelper<placed_feature,0> { placed_feature() : Object("placed_feature") {}
+
+    };
+
+    // C++ wrapper for planar_extent
+    struct planar_extent : geometric_representation_item, ObjectHelper<planar_extent,2> { planar_extent() : Object("planar_extent") {}
+		length_measure::Out size_in_x;
+		length_measure::Out size_in_y;
+    };
+
+    // C++ wrapper for planar_box
+    struct planar_box : planar_extent, ObjectHelper<planar_box,1> { planar_box() : Object("planar_box") {}
+		axis2_placement::Out placement;
+    };
+
+    // C++ wrapper for plane
+    struct plane : elementary_surface, ObjectHelper<plane,0> { plane() : Object("plane") {}
+
+    };
+
+    // C++ wrapper for plane_angle_measure_with_unit
+    struct plane_angle_measure_with_unit : measure_with_unit, ObjectHelper<plane_angle_measure_with_unit,0> { plane_angle_measure_with_unit() : Object("plane_angle_measure_with_unit") {}
+
+    };
+
+    // C++ wrapper for plane_angle_unit
+    struct plane_angle_unit : named_unit, ObjectHelper<plane_angle_unit,0> { plane_angle_unit() : Object("plane_angle_unit") {}
+
+    };
+
+    // C++ wrapper for ply_laminate_definition
+    struct ply_laminate_definition : product_definition, ObjectHelper<ply_laminate_definition,0> { ply_laminate_definition() : Object("ply_laminate_definition") {}
+
+    };
+
+    // C++ wrapper for ply_laminate_sequence_definition
+    struct ply_laminate_sequence_definition : product_definition, ObjectHelper<ply_laminate_sequence_definition,0> { ply_laminate_sequence_definition() : Object("ply_laminate_sequence_definition") {}
+
+    };
+
+    // C++ wrapper for ply_laminate_table
+    struct ply_laminate_table : part_laminate_table, ObjectHelper<ply_laminate_table,0> { ply_laminate_table() : Object("ply_laminate_table") {}
+
+    };
+
+    // C++ wrapper for point_and_vector
+    struct point_and_vector :  ObjectHelper<point_and_vector,0> { point_and_vector() : Object("point_and_vector") {}
+
+    };
+
+    // C++ wrapper for point_on_curve
+    struct point_on_curve : point, ObjectHelper<point_on_curve,2> { point_on_curve() : Object("point_on_curve") {}
+		Lazy< curve > basis_curve;
+		parameter_value::Out point_parameter;
+    };
+
+    // C++ wrapper for point_on_surface
+    struct point_on_surface : point, ObjectHelper<point_on_surface,3> { point_on_surface() : Object("point_on_surface") {}
+		Lazy< surface > basis_surface;
+		parameter_value::Out point_parameter_u;
+		parameter_value::Out point_parameter_v;
+    };
+
+    // C++ wrapper for point_path
+    struct point_path :  ObjectHelper<point_path,0> { point_path() : Object("point_path") {}
+
+    };
+
+    // C++ wrapper for point_replica
+    struct point_replica : point, ObjectHelper<point_replica,2> { point_replica() : Object("point_replica") {}
+		Lazy< point > parent_pt;
+		Lazy< cartesian_transformation_operator > transformation;
+    };
+
+    // C++ wrapper for point_style
+    struct point_style : founded_item, ObjectHelper<point_style,4> { point_style() : Object("point_style") {}
+		label::Out name;
+		marker_select::Out marker;
+		size_select::Out marker_size;
+		Lazy< colour > marker_colour;
+    };
+
+    // C++ wrapper for polar_complex_number_literal
+    struct polar_complex_number_literal : generic_literal, ObjectHelper<polar_complex_number_literal,2> { polar_complex_number_literal() : Object("polar_complex_number_literal") {}
+		REAL::Out radius;
+		REAL::Out angle;
+    };
+
+    // C++ wrapper for poly_loop
+    struct poly_loop :  ObjectHelper<poly_loop,1> { poly_loop() : Object("poly_loop") {}
+		ListOf< Lazy< cartesian_point >, 3, 0 > polygon;
+    };
+
+    // C++ wrapper for polyline
+    struct polyline : bounded_curve, ObjectHelper<polyline,1> { polyline() : Object("polyline") {}
+		ListOf< Lazy< cartesian_point >, 2, 0 > points;
+    };
+
+    // C++ wrapper for position_tolerance
+    struct position_tolerance : geometric_tolerance, ObjectHelper<position_tolerance,0> { position_tolerance() : Object("position_tolerance") {}
+
+    };
+
+    // C++ wrapper for positioned_sketch
+    struct positioned_sketch : geometric_representation_item, ObjectHelper<positioned_sketch,2> { positioned_sketch() : Object("positioned_sketch") {}
+		sketch_basis_select::Out sketch_basis;
+		ListOf< Lazy< auxiliary_geometric_representation_item >, 0, 0 > auxiliary_elements;
+    };
+
+    // C++ wrapper for power_measure_with_unit
+    struct power_measure_with_unit : measure_with_unit, ObjectHelper<power_measure_with_unit,0> { power_measure_with_unit() : Object("power_measure_with_unit") {}
+
+    };
+
+    // C++ wrapper for power_unit
+    struct power_unit : derived_unit, ObjectHelper<power_unit,0> { power_unit() : Object("power_unit") {}
+
+    };
+
+    // C++ wrapper for pre_defined_symbol
+    struct pre_defined_symbol : pre_defined_item, ObjectHelper<pre_defined_symbol,0> { pre_defined_symbol() : Object("pre_defined_symbol") {}
+
+    };
+
+    // C++ wrapper for pre_defined_dimension_symbol
+    struct pre_defined_dimension_symbol : pre_defined_symbol, ObjectHelper<pre_defined_dimension_symbol,0> { pre_defined_dimension_symbol() : Object("pre_defined_dimension_symbol") {}
+
+    };
+
+    // C++ wrapper for pre_defined_geometrical_tolerance_symbol
+    struct pre_defined_geometrical_tolerance_symbol : pre_defined_symbol, ObjectHelper<pre_defined_geometrical_tolerance_symbol,0> { pre_defined_geometrical_tolerance_symbol() : Object("pre_defined_geometrical_tolerance_symbol") {}
+
+    };
+
+    // C++ wrapper for pre_defined_marker
+    struct pre_defined_marker : pre_defined_item, ObjectHelper<pre_defined_marker,0> { pre_defined_marker() : Object("pre_defined_marker") {}
+
+    };
+
+    // C++ wrapper for pre_defined_point_marker_symbol
+    struct pre_defined_point_marker_symbol :  ObjectHelper<pre_defined_point_marker_symbol,0> { pre_defined_point_marker_symbol() : Object("pre_defined_point_marker_symbol") {}
+
+    };
+
+    // C++ wrapper for pre_defined_surface_condition_symbol
+    struct pre_defined_surface_condition_symbol : pre_defined_symbol, ObjectHelper<pre_defined_surface_condition_symbol,0> { pre_defined_surface_condition_symbol() : Object("pre_defined_surface_condition_symbol") {}
+
+    };
+
+    // C++ wrapper for pre_defined_surface_side_style
+    struct pre_defined_surface_side_style : pre_defined_item, ObjectHelper<pre_defined_surface_side_style,0> { pre_defined_surface_side_style() : Object("pre_defined_surface_side_style") {}
+
+    };
+
+    // C++ wrapper for pre_defined_terminator_symbol
+    struct pre_defined_terminator_symbol : pre_defined_symbol, ObjectHelper<pre_defined_terminator_symbol,0> { pre_defined_terminator_symbol() : Object("pre_defined_terminator_symbol") {}
+
+    };
+
+    // C++ wrapper for pre_defined_tile
+    struct pre_defined_tile : pre_defined_item, ObjectHelper<pre_defined_tile,0> { pre_defined_tile() : Object("pre_defined_tile") {}
+
+    };
+
+    // C++ wrapper for predefined_picture_representation_item
+    struct predefined_picture_representation_item : picture_representation_item, ObjectHelper<predefined_picture_representation_item,0> { predefined_picture_representation_item() : Object("predefined_picture_representation_item") {}
+
+    };
+
+    // C++ wrapper for presentation_style_assignment
+    struct presentation_style_assignment : founded_item, ObjectHelper<presentation_style_assignment,1> { presentation_style_assignment() : Object("presentation_style_assignment") {}
+		ListOf< presentation_style_select, 1, 0 >::Out styles;
+    };
+
+    // C++ wrapper for presentation_style_by_context
+    struct presentation_style_by_context : presentation_style_assignment, ObjectHelper<presentation_style_by_context,1> { presentation_style_by_context() : Object("presentation_style_by_context") {}
+		style_context_select::Out style_context;
+    };
+
+    // C++ wrapper for pressure_measure_with_unit
+    struct pressure_measure_with_unit : measure_with_unit, ObjectHelper<pressure_measure_with_unit,0> { pressure_measure_with_unit() : Object("pressure_measure_with_unit") {}
+
+    };
+
+    // C++ wrapper for pressure_unit
+    struct pressure_unit : derived_unit, ObjectHelper<pressure_unit,0> { pressure_unit() : Object("pressure_unit") {}
+
+    };
+
+    // C++ wrapper for procedural_representation
+    struct procedural_representation : representation, ObjectHelper<procedural_representation,0> { procedural_representation() : Object("procedural_representation") {}
+
+    };
+
+    // C++ wrapper for procedural_representation_sequence
+    struct procedural_representation_sequence : representation_item, ObjectHelper<procedural_representation_sequence,3> { procedural_representation_sequence() : Object("procedural_representation_sequence") {}
+		ListOf< Lazy< representation_item >, 1, 0 > elements;
+		ListOf< Lazy< representation_item >, 0, 0 > suppressed_items;
+		text::Out rationale;
+    };
+
+    // C++ wrapper for procedural_shape_representation
+    struct procedural_shape_representation :  ObjectHelper<procedural_shape_representation,0> { procedural_shape_representation() : Object("procedural_shape_representation") {}
+
+    };
+
+    // C++ wrapper for procedural_shape_representation_sequence
+    struct procedural_shape_representation_sequence :  ObjectHelper<procedural_shape_representation_sequence,0> { procedural_shape_representation_sequence() : Object("procedural_shape_representation_sequence") {}
+
+    };
+
+    // C++ wrapper for product_category
+    struct product_category :  ObjectHelper<product_category,2> { product_category() : Object("product_category") {}
+		label::Out name;
+		Maybe< text::Out > description;
+    };
+
+    // C++ wrapper for product_class
+    struct product_class :  ObjectHelper<product_class,0> { product_class() : Object("product_class") {}
+
+    };
+
+    // C++ wrapper for product_concept_context
+    struct product_concept_context : application_context_element, ObjectHelper<product_concept_context,1> { product_concept_context() : Object("product_concept_context") {}
+		label::Out market_segment_type;
+    };
+
+    // C++ wrapper for product_concept_feature_category_usage
+    struct product_concept_feature_category_usage : group_assignment, ObjectHelper<product_concept_feature_category_usage,1> { product_concept_feature_category_usage() : Object("product_concept_feature_category_usage") {}
+		ListOf< category_usage_item, 1, 0 >::Out items;
+    };
+
+    // C++ wrapper for product_definition_element_relationship
+    struct product_definition_element_relationship : group, ObjectHelper<product_definition_element_relationship,0> { product_definition_element_relationship() : Object("product_definition_element_relationship") {}
+
+    };
+
+    // C++ wrapper for product_definition_formation
+    struct product_definition_formation :  ObjectHelper<product_definition_formation,3> { product_definition_formation() : Object("product_definition_formation") {}
+		identifier::Out id;
+		Maybe< text::Out > description;
+		Lazy< NotImplemented > of_product;
+    };
+
+    // C++ wrapper for product_definition_formation_with_specified_source
+    struct product_definition_formation_with_specified_source : product_definition_formation, ObjectHelper<product_definition_formation_with_specified_source,1> { product_definition_formation_with_specified_source() : Object("product_definition_formation_with_specified_source") {}
+		source::Out make_or_buy;
+    };
+
+    // C++ wrapper for product_definition_group_assignment
+    struct product_definition_group_assignment : group_assignment, ObjectHelper<product_definition_group_assignment,1> { product_definition_group_assignment() : Object("product_definition_group_assignment") {}
+		ListOf< product_definition_or_product_definition_relationship, 1, 1 >::Out items;
+    };
+
+    // C++ wrapper for product_definition_shape
+    struct product_definition_shape : property_definition, ObjectHelper<product_definition_shape,0> { product_definition_shape() : Object("product_definition_shape") {}
+
+    };
+
+    // C++ wrapper for product_definition_with_associated_documents
+    struct product_definition_with_associated_documents : product_definition, ObjectHelper<product_definition_with_associated_documents,1> { product_definition_with_associated_documents() : Object("product_definition_with_associated_documents") {}
+		ListOf< Lazy< NotImplemented >, 1, 0 > documentation_ids;
+    };
+
+    // C++ wrapper for product_identification
+    struct product_identification :  ObjectHelper<product_identification,0> { product_identification() : Object("product_identification") {}
+
+    };
+
+    // C++ wrapper for product_material_composition_relationship
+    struct product_material_composition_relationship : product_definition_relationship, ObjectHelper<product_material_composition_relationship,4> { product_material_composition_relationship() : Object("product_material_composition_relationship") {}
+		label::Out class_;
+		ListOf< characterized_product_composition_value, 1, 0 >::Out constituent_amount;
+		label::Out composition_basis;
+		text::Out determination_method;
+    };
+
+    // C++ wrapper for product_related_product_category
+    struct product_related_product_category : product_category, ObjectHelper<product_related_product_category,1> { product_related_product_category() : Object("product_related_product_category") {}
+		ListOf< Lazy< NotImplemented >, 1, 0 > products;
+    };
+
+    // C++ wrapper for product_specification
+    struct product_specification :  ObjectHelper<product_specification,0> { product_specification() : Object("product_specification") {}
+
+    };
+
+    // C++ wrapper for tolerance_zone_definition
+    struct tolerance_zone_definition :  ObjectHelper<tolerance_zone_definition,2> { tolerance_zone_definition() : Object("tolerance_zone_definition") {}
+		Lazy< tolerance_zone > zone;
+		ListOf< Lazy< shape_aspect >, 1, 0 > boundaries;
+    };
+
+    // C++ wrapper for projected_zone_definition
+    struct projected_zone_definition : tolerance_zone_definition, ObjectHelper<projected_zone_definition,2> { projected_zone_definition() : Object("projected_zone_definition") {}
+		Lazy< shape_aspect > projection_end;
+		Lazy< measure_with_unit > projected_length;
+    };
+
+    // C++ wrapper for projection_curve
+    struct projection_curve : annotation_curve_occurrence, ObjectHelper<projection_curve,0> { projection_curve() : Object("projection_curve") {}
+
+    };
+
+    // C++ wrapper for promissory_usage_occurrence
+    struct promissory_usage_occurrence : assembly_component_usage, ObjectHelper<promissory_usage_occurrence,0> { promissory_usage_occurrence() : Object("promissory_usage_occurrence") {}
+
+    };
+
+    // C++ wrapper for qualified_representation_item
+    struct qualified_representation_item : representation_item, ObjectHelper<qualified_representation_item,1> { qualified_representation_item() : Object("qualified_representation_item") {}
+		ListOf< value_qualifier, 1, 0 >::Out qualifiers;
+    };
+
+    // C++ wrapper for qualitative_uncertainty
+    struct qualitative_uncertainty : uncertainty_qualifier, ObjectHelper<qualitative_uncertainty,1> { qualitative_uncertainty() : Object("qualitative_uncertainty") {}
+		text::Out uncertainty_value;
+    };
+
+    // C++ wrapper for quantified_assembly_component_usage
+    struct quantified_assembly_component_usage : assembly_component_usage, ObjectHelper<quantified_assembly_component_usage,1> { quantified_assembly_component_usage() : Object("quantified_assembly_component_usage") {}
+		Lazy< measure_with_unit > quantity;
+    };
+
+    // C++ wrapper for quasi_uniform_curve
+    struct quasi_uniform_curve : b_spline_curve, ObjectHelper<quasi_uniform_curve,0> { quasi_uniform_curve() : Object("quasi_uniform_curve") {}
+
+    };
+
+    // C++ wrapper for quasi_uniform_surface
+    struct quasi_uniform_surface : b_spline_surface, ObjectHelper<quasi_uniform_surface,0> { quasi_uniform_surface() : Object("quasi_uniform_surface") {}
+
+    };
+
+    // C++ wrapper for radioactivity_measure_with_unit
+    struct radioactivity_measure_with_unit : measure_with_unit, ObjectHelper<radioactivity_measure_with_unit,0> { radioactivity_measure_with_unit() : Object("radioactivity_measure_with_unit") {}
+
+    };
+
+    // C++ wrapper for radioactivity_unit
+    struct radioactivity_unit : derived_unit, ObjectHelper<radioactivity_unit,0> { radioactivity_unit() : Object("radioactivity_unit") {}
+
+    };
+
+    // C++ wrapper for radius_dimension
+    struct radius_dimension : dimension_curve_directed_callout, ObjectHelper<radius_dimension,0> { radius_dimension() : Object("radius_dimension") {}
+
+    };
+
+    // C++ wrapper for range_characteristic
+    struct range_characteristic :  ObjectHelper<range_characteristic,0> { range_characteristic() : Object("range_characteristic") {}
+
+    };
+
+    // C++ wrapper for ratio_unit
+    struct ratio_unit : named_unit, ObjectHelper<ratio_unit,0> { ratio_unit() : Object("ratio_unit") {}
+
+    };
+
+    // C++ wrapper for rational_b_spline_curve
+    struct rational_b_spline_curve : b_spline_curve, ObjectHelper<rational_b_spline_curve,1> { rational_b_spline_curve() : Object("rational_b_spline_curve") {}
+		ListOf< REAL, 2, 0 >::Out weights_data;
+    };
+
+    // C++ wrapper for rational_b_spline_surface
+    struct rational_b_spline_surface : b_spline_surface, ObjectHelper<rational_b_spline_surface,0> { rational_b_spline_surface() : Object("rational_b_spline_surface") {}
+
+    };
+
+    // C++ wrapper for rational_representation_item
+    struct rational_representation_item :  ObjectHelper<rational_representation_item,0> { rational_representation_item() : Object("rational_representation_item") {}
+
+    };
+
+    // C++ wrapper for real_literal
+    struct real_literal : literal_number, ObjectHelper<real_literal,0> { real_literal() : Object("real_literal") {}
+
+    };
+
+    // C++ wrapper for real_representation_item
+    struct real_representation_item :  ObjectHelper<real_representation_item,0> { real_representation_item() : Object("real_representation_item") {}
+
+    };
+
+    // C++ wrapper for rectangular_composite_surface
+    struct rectangular_composite_surface : bounded_surface, ObjectHelper<rectangular_composite_surface,0> { rectangular_composite_surface() : Object("rectangular_composite_surface") {}
+
+    };
+
+    // C++ wrapper for rectangular_trimmed_surface
+    struct rectangular_trimmed_surface : bounded_surface, ObjectHelper<rectangular_trimmed_surface,7> { rectangular_trimmed_surface() : Object("rectangular_trimmed_surface") {}
+		Lazy< surface > basis_surface;
+		parameter_value::Out u1;
+		parameter_value::Out u2;
+		parameter_value::Out v1;
+		parameter_value::Out v2;
+		BOOLEAN::Out usense;
+		BOOLEAN::Out vsense;
+    };
+
+    // C++ wrapper for referenced_modified_datum
+    struct referenced_modified_datum : datum_reference, ObjectHelper<referenced_modified_datum,1> { referenced_modified_datum() : Object("referenced_modified_datum") {}
+		limit_condition::Out modifier;
+    };
+
+    // C++ wrapper for relative_event_occurrence
+    struct relative_event_occurrence : event_occurrence, ObjectHelper<relative_event_occurrence,2> { relative_event_occurrence() : Object("relative_event_occurrence") {}
+		Lazy< event_occurrence > base_event;
+		Lazy< time_measure_with_unit > offset;
+    };
+
+    // C++ wrapper for rep_item_group
+    struct rep_item_group :  ObjectHelper<rep_item_group,0> { rep_item_group() : Object("rep_item_group") {}
+
+    };
+
+    // C++ wrapper for reparametrised_composite_curve_segment
+    struct reparametrised_composite_curve_segment : composite_curve_segment, ObjectHelper<reparametrised_composite_curve_segment,1> { reparametrised_composite_curve_segment() : Object("reparametrised_composite_curve_segment") {}
+		parameter_value::Out param_length;
+    };
+
+    // C++ wrapper for representation_relationship_with_transformation
+    struct representation_relationship_with_transformation : representation_relationship, ObjectHelper<representation_relationship_with_transformation,1> { representation_relationship_with_transformation() : Object("representation_relationship_with_transformation") {}
+		transformation::Out transformation_operator;
+    };
+
+    // C++ wrapper for requirement_assigned_object
+    struct requirement_assigned_object : group_assignment, ObjectHelper<requirement_assigned_object,1> { requirement_assigned_object() : Object("requirement_assigned_object") {}
+		ListOf< requirement_assigned_item, 1, 1 >::Out items;
+    };
+
+    // C++ wrapper for requirement_assignment
+    struct requirement_assignment :  ObjectHelper<requirement_assignment,0> { requirement_assignment() : Object("requirement_assignment") {}
+
+    };
+
+    // C++ wrapper for requirement_source
+    struct requirement_source : group, ObjectHelper<requirement_source,0> { requirement_source() : Object("requirement_source") {}
+
+    };
+
+    // C++ wrapper for requirement_view_definition_relationship
+    struct requirement_view_definition_relationship : product_definition_relationship, ObjectHelper<requirement_view_definition_relationship,0> { requirement_view_definition_relationship() : Object("requirement_view_definition_relationship") {}
+
+    };
+
+    // C++ wrapper for resistance_measure_with_unit
+    struct resistance_measure_with_unit : measure_with_unit, ObjectHelper<resistance_measure_with_unit,0> { resistance_measure_with_unit() : Object("resistance_measure_with_unit") {}
+
+    };
+
+    // C++ wrapper for resistance_unit
+    struct resistance_unit : derived_unit, ObjectHelper<resistance_unit,0> { resistance_unit() : Object("resistance_unit") {}
+
+    };
+
+    // C++ wrapper for revolved_area_solid
+    struct revolved_area_solid : swept_area_solid, ObjectHelper<revolved_area_solid,2> { revolved_area_solid() : Object("revolved_area_solid") {}
+		Lazy< axis1_placement > axis;
+		plane_angle_measure::Out angle;
+    };
+
+    // C++ wrapper for revolved_face_solid
+    struct revolved_face_solid : swept_face_solid, ObjectHelper<revolved_face_solid,2> { revolved_face_solid() : Object("revolved_face_solid") {}
+		Lazy< axis1_placement > axis;
+		plane_angle_measure::Out angle;
+    };
+
+    // C++ wrapper for revolved_face_solid_with_trim_conditions
+    struct revolved_face_solid_with_trim_conditions : revolved_face_solid, ObjectHelper<revolved_face_solid_with_trim_conditions,2> { revolved_face_solid_with_trim_conditions() : Object("revolved_face_solid_with_trim_conditions") {}
+		trim_condition_select::Out first_trim_condition;
+		trim_condition_select::Out second_trim_condition;
+    };
+
+    // C++ wrapper for right_angular_wedge
+    struct right_angular_wedge : geometric_representation_item, ObjectHelper<right_angular_wedge,5> { right_angular_wedge() : Object("right_angular_wedge") {}
+		Lazy< axis2_placement_3d > position;
+		positive_length_measure::Out x;
+		positive_length_measure::Out y;
+		positive_length_measure::Out z;
+		length_measure::Out ltx;
+    };
+
+    // C++ wrapper for right_circular_cone
+    struct right_circular_cone : geometric_representation_item, ObjectHelper<right_circular_cone,4> { right_circular_cone() : Object("right_circular_cone") {}
+		Lazy< axis1_placement > position;
+		positive_length_measure::Out height;
+		length_measure::Out radius;
+		plane_angle_measure::Out semi_angle;
+    };
+
+    // C++ wrapper for right_circular_cylinder
+    struct right_circular_cylinder : geometric_representation_item, ObjectHelper<right_circular_cylinder,3> { right_circular_cylinder() : Object("right_circular_cylinder") {}
+		Lazy< axis1_placement > position;
+		positive_length_measure::Out height;
+		positive_length_measure::Out radius;
+    };
+
+    // C++ wrapper for right_to_usage_association
+    struct right_to_usage_association : action_method_relationship, ObjectHelper<right_to_usage_association,0> { right_to_usage_association() : Object("right_to_usage_association") {}
+
+    };
+
+    // C++ wrapper for roundness_tolerance
+    struct roundness_tolerance : geometric_tolerance, ObjectHelper<roundness_tolerance,0> { roundness_tolerance() : Object("roundness_tolerance") {}
+
+    };
+
+    // C++ wrapper for row_representation_item
+    struct row_representation_item : compound_representation_item, ObjectHelper<row_representation_item,0> { row_representation_item() : Object("row_representation_item") {}
+
+    };
+
+    // C++ wrapper for row_value
+    struct row_value : compound_representation_item, ObjectHelper<row_value,0> { row_value() : Object("row_value") {}
+
+    };
+
+    // C++ wrapper for row_variable
+    struct row_variable : abstract_variable, ObjectHelper<row_variable,0> { row_variable() : Object("row_variable") {}
+
+    };
+
+    // C++ wrapper for rule_action
+    struct rule_action : action, ObjectHelper<rule_action,0> { rule_action() : Object("rule_action") {}
+
+    };
+
+    // C++ wrapper for rule_condition
+    struct rule_condition : atomic_formula, ObjectHelper<rule_condition,0> { rule_condition() : Object("rule_condition") {}
+
+    };
+
+    // C++ wrapper for rule_set
+    struct rule_set : rule_software_definition, ObjectHelper<rule_set,0> { rule_set() : Object("rule_set") {}
+
+    };
+
+    // C++ wrapper for rule_set_group
+    struct rule_set_group : rule_software_definition, ObjectHelper<rule_set_group,0> { rule_set_group() : Object("rule_set_group") {}
+
+    };
+
+    // C++ wrapper for rule_superseded_assignment
+    struct rule_superseded_assignment : action_assignment, ObjectHelper<rule_superseded_assignment,1> { rule_superseded_assignment() : Object("rule_superseded_assignment") {}
+		ListOf< rule_superseded_item, 1, 0 >::Out items;
+    };
+
+    // C++ wrapper for rule_supersedence
+    struct rule_supersedence : rule_action, ObjectHelper<rule_supersedence,0> { rule_supersedence() : Object("rule_supersedence") {}
+
+    };
+
+    // C++ wrapper for surface_curve_swept_area_solid
+    struct surface_curve_swept_area_solid : swept_area_solid, ObjectHelper<surface_curve_swept_area_solid,4> { surface_curve_swept_area_solid() : Object("surface_curve_swept_area_solid") {}
+		Lazy< curve > directrix;
+		REAL::Out start_param;
+		REAL::Out end_param;
+		Lazy< surface > reference_surface;
+    };
+
+    // C++ wrapper for ruled_surface_swept_area_solid
+    struct ruled_surface_swept_area_solid : surface_curve_swept_area_solid, ObjectHelper<ruled_surface_swept_area_solid,0> { ruled_surface_swept_area_solid() : Object("ruled_surface_swept_area_solid") {}
+
+    };
+
+    // C++ wrapper for runout_zone_definition
+    struct runout_zone_definition : tolerance_zone_definition, ObjectHelper<runout_zone_definition,1> { runout_zone_definition() : Object("runout_zone_definition") {}
+		Lazy< runout_zone_orientation > orientation;
+    };
+
+    // C++ wrapper for runout_zone_orientation
+    struct runout_zone_orientation :  ObjectHelper<runout_zone_orientation,1> { runout_zone_orientation() : Object("runout_zone_orientation") {}
+		Lazy< measure_with_unit > angle;
+    };
+
+    // C++ wrapper for runout_zone_orientation_reference_direction
+    struct runout_zone_orientation_reference_direction : runout_zone_orientation, ObjectHelper<runout_zone_orientation_reference_direction,1> { runout_zone_orientation_reference_direction() : Object("runout_zone_orientation_reference_direction") {}
+		Lazy< shape_aspect_relationship > orientation_defining_relationship;
+    };
+
+    // C++ wrapper for satisfied_requirement
+    struct satisfied_requirement : group_assignment, ObjectHelper<satisfied_requirement,1> { satisfied_requirement() : Object("satisfied_requirement") {}
+		ListOf< Lazy< product_definition >, 1, 1 > items;
+    };
+
+    // C++ wrapper for satisfies_requirement
+    struct satisfies_requirement : group, ObjectHelper<satisfies_requirement,0> { satisfies_requirement() : Object("satisfies_requirement") {}
+
+    };
+
+    // C++ wrapper for satisfying_item
+    struct satisfying_item : group_assignment, ObjectHelper<satisfying_item,1> { satisfying_item() : Object("satisfying_item") {}
+		ListOf< requirement_satisfaction_item, 1, 1 >::Out items;
+    };
+
+    // C++ wrapper for scalar_variable
+    struct scalar_variable : abstract_variable, ObjectHelper<scalar_variable,0> { scalar_variable() : Object("scalar_variable") {}
+
+    };
+
+    // C++ wrapper for scattering_parameter
+    struct scattering_parameter : polar_complex_number_literal, ObjectHelper<scattering_parameter,0> { scattering_parameter() : Object("scattering_parameter") {}
+
+    };
+
+    // C++ wrapper for sculptured_solid
+    struct sculptured_solid : modified_solid, ObjectHelper<sculptured_solid,2> { sculptured_solid() : Object("sculptured_solid") {}
+		generalized_surface_select::Out sculpturing_element;
+		BOOLEAN::Out positive_side;
+    };
+
+    // C++ wrapper for seam_curve
+    struct seam_curve : surface_curve, ObjectHelper<seam_curve,0> { seam_curve() : Object("seam_curve") {}
+
+    };
+
+    // C++ wrapper for serial_numbered_effectivity
+    struct serial_numbered_effectivity : effectivity, ObjectHelper<serial_numbered_effectivity,2> { serial_numbered_effectivity() : Object("serial_numbered_effectivity") {}
+		identifier::Out effectivity_start_id;
+		Maybe< identifier::Out > effectivity_end_id;
+    };
+
+    // C++ wrapper for shape_aspect_associativity
+    struct shape_aspect_associativity : shape_aspect_relationship, ObjectHelper<shape_aspect_associativity,0> { shape_aspect_associativity() : Object("shape_aspect_associativity") {}
+
+    };
+
+    // C++ wrapper for shape_aspect_deriving_relationship
+    struct shape_aspect_deriving_relationship : shape_aspect_relationship, ObjectHelper<shape_aspect_deriving_relationship,0> { shape_aspect_deriving_relationship() : Object("shape_aspect_deriving_relationship") {}
+
+    };
+
+    // C++ wrapper for shape_definition_representation
+    struct shape_definition_representation : property_definition_representation, ObjectHelper<shape_definition_representation,0> { shape_definition_representation() : Object("shape_definition_representation") {}
+
+    };
+
+    // C++ wrapper for shape_dimension_representation
+    struct shape_dimension_representation : shape_representation, ObjectHelper<shape_dimension_representation,0> { shape_dimension_representation() : Object("shape_dimension_representation") {}
+
+    };
+
+    // C++ wrapper for shape_feature_definition
+    struct shape_feature_definition : characterized_object, ObjectHelper<shape_feature_definition,0> { shape_feature_definition() : Object("shape_feature_definition") {}
+
+    };
+
+    // C++ wrapper for shape_representation_with_parameters
+    struct shape_representation_with_parameters : shape_representation, ObjectHelper<shape_representation_with_parameters,0> { shape_representation_with_parameters() : Object("shape_representation_with_parameters") {}
+
+    };
+
+    // C++ wrapper for shell_based_surface_model
+    struct shell_based_surface_model : geometric_representation_item, ObjectHelper<shell_based_surface_model,1> { shell_based_surface_model() : Object("shell_based_surface_model") {}
+		ListOf< shell, 1, 0 >::Out sbsm_boundary;
+    };
+
+    // C++ wrapper for shell_based_wireframe_model
+    struct shell_based_wireframe_model : geometric_representation_item, ObjectHelper<shell_based_wireframe_model,1> { shell_based_wireframe_model() : Object("shell_based_wireframe_model") {}
+		ListOf< shell, 1, 0 >::Out sbwm_boundary;
+    };
+
+    // C++ wrapper for shell_based_wireframe_shape_representation
+    struct shell_based_wireframe_shape_representation : shape_representation, ObjectHelper<shell_based_wireframe_shape_representation,0> { shell_based_wireframe_shape_representation() : Object("shell_based_wireframe_shape_representation") {}
+
+    };
+
+    // C++ wrapper for si_absorbed_dose_unit
+    struct si_absorbed_dose_unit :  ObjectHelper<si_absorbed_dose_unit,0> { si_absorbed_dose_unit() : Object("si_absorbed_dose_unit") {}
+
+    };
+
+    // C++ wrapper for si_capacitance_unit
+    struct si_capacitance_unit :  ObjectHelper<si_capacitance_unit,0> { si_capacitance_unit() : Object("si_capacitance_unit") {}
+
+    };
+
+    // C++ wrapper for si_conductance_unit
+    struct si_conductance_unit :  ObjectHelper<si_conductance_unit,0> { si_conductance_unit() : Object("si_conductance_unit") {}
+
+    };
+
+    // C++ wrapper for si_dose_equivalent_unit
+    struct si_dose_equivalent_unit :  ObjectHelper<si_dose_equivalent_unit,0> { si_dose_equivalent_unit() : Object("si_dose_equivalent_unit") {}
+
+    };
+
+    // C++ wrapper for si_electric_charge_unit
+    struct si_electric_charge_unit :  ObjectHelper<si_electric_charge_unit,0> { si_electric_charge_unit() : Object("si_electric_charge_unit") {}
+
+    };
+
+    // C++ wrapper for si_electric_potential_unit
+    struct si_electric_potential_unit :  ObjectHelper<si_electric_potential_unit,0> { si_electric_potential_unit() : Object("si_electric_potential_unit") {}
+
+    };
+
+    // C++ wrapper for si_energy_unit
+    struct si_energy_unit :  ObjectHelper<si_energy_unit,0> { si_energy_unit() : Object("si_energy_unit") {}
+
+    };
+
+    // C++ wrapper for si_force_unit
+    struct si_force_unit :  ObjectHelper<si_force_unit,0> { si_force_unit() : Object("si_force_unit") {}
+
+    };
+
+    // C++ wrapper for si_frequency_unit
+    struct si_frequency_unit :  ObjectHelper<si_frequency_unit,0> { si_frequency_unit() : Object("si_frequency_unit") {}
+
+    };
+
+    // C++ wrapper for si_illuminance_unit
+    struct si_illuminance_unit :  ObjectHelper<si_illuminance_unit,0> { si_illuminance_unit() : Object("si_illuminance_unit") {}
+
+    };
+
+    // C++ wrapper for si_inductance_unit
+    struct si_inductance_unit :  ObjectHelper<si_inductance_unit,0> { si_inductance_unit() : Object("si_inductance_unit") {}
+
+    };
+
+    // C++ wrapper for si_magnetic_flux_density_unit
+    struct si_magnetic_flux_density_unit :  ObjectHelper<si_magnetic_flux_density_unit,0> { si_magnetic_flux_density_unit() : Object("si_magnetic_flux_density_unit") {}
+
+    };
+
+    // C++ wrapper for si_magnetic_flux_unit
+    struct si_magnetic_flux_unit :  ObjectHelper<si_magnetic_flux_unit,0> { si_magnetic_flux_unit() : Object("si_magnetic_flux_unit") {}
+
+    };
+
+    // C++ wrapper for si_power_unit
+    struct si_power_unit :  ObjectHelper<si_power_unit,0> { si_power_unit() : Object("si_power_unit") {}
+
+    };
+
+    // C++ wrapper for si_pressure_unit
+    struct si_pressure_unit :  ObjectHelper<si_pressure_unit,0> { si_pressure_unit() : Object("si_pressure_unit") {}
+
+    };
+
+    // C++ wrapper for si_radioactivity_unit
+    struct si_radioactivity_unit :  ObjectHelper<si_radioactivity_unit,0> { si_radioactivity_unit() : Object("si_radioactivity_unit") {}
+
+    };
+
+    // C++ wrapper for si_resistance_unit
+    struct si_resistance_unit :  ObjectHelper<si_resistance_unit,0> { si_resistance_unit() : Object("si_resistance_unit") {}
+
+    };
+
+    // C++ wrapper for si_unit
+    struct si_unit : named_unit, ObjectHelper<si_unit,2> { si_unit() : Object("si_unit") {}
+		Maybe< si_prefix::Out > prefix;
+		si_unit_name::Out name;
+    };
+
+    // C++ wrapper for simple_boolean_expression
+    struct simple_boolean_expression :  ObjectHelper<simple_boolean_expression,0> { simple_boolean_expression() : Object("simple_boolean_expression") {}
+
+    };
+
+    // C++ wrapper for simple_numeric_expression
+    struct simple_numeric_expression :  ObjectHelper<simple_numeric_expression,0> { simple_numeric_expression() : Object("simple_numeric_expression") {}
+
+    };
+
+    // C++ wrapper for slash_expression
+    struct slash_expression : binary_numeric_expression, ObjectHelper<slash_expression,0> { slash_expression() : Object("slash_expression") {}
+
+    };
+
+    // C++ wrapper for smeared_material_definition
+    struct smeared_material_definition : zone_structural_makeup, ObjectHelper<smeared_material_definition,0> { smeared_material_definition() : Object("smeared_material_definition") {}
+
+    };
+
+    // C++ wrapper for solid_angle_measure_with_unit
+    struct solid_angle_measure_with_unit : measure_with_unit, ObjectHelper<solid_angle_measure_with_unit,0> { solid_angle_measure_with_unit() : Object("solid_angle_measure_with_unit") {}
+
+    };
+
+    // C++ wrapper for solid_angle_unit
+    struct solid_angle_unit : named_unit, ObjectHelper<solid_angle_unit,0> { solid_angle_unit() : Object("solid_angle_unit") {}
+
+    };
+
+    // C++ wrapper for solid_curve_font
+    struct solid_curve_font : pre_defined_curve_font, ObjectHelper<solid_curve_font,0> { solid_curve_font() : Object("solid_curve_font") {}
+
+    };
+
+    // C++ wrapper for solid_replica
+    struct solid_replica : solid_model, ObjectHelper<solid_replica,2> { solid_replica() : Object("solid_replica") {}
+		Lazy< solid_model > parent_solid;
+		Lazy< cartesian_transformation_operator_3d > transformation;
+    };
+
+    // C++ wrapper for solid_with_chamfered_edges
+    struct solid_with_chamfered_edges : edge_blended_solid, ObjectHelper<solid_with_chamfered_edges,0> { solid_with_chamfered_edges() : Object("solid_with_chamfered_edges") {}
+
+    };
+
+    // C++ wrapper for solid_with_angle_based_chamfer
+    struct solid_with_angle_based_chamfer : solid_with_chamfered_edges, ObjectHelper<solid_with_angle_based_chamfer,3> { solid_with_angle_based_chamfer() : Object("solid_with_angle_based_chamfer") {}
+		positive_length_measure::Out offset_distance;
+		BOOLEAN::Out left_offset;
+		positive_plane_angle_measure::Out offset_angle;
+    };
+
+    // C++ wrapper for solid_with_shape_element_pattern
+    struct solid_with_shape_element_pattern : modified_solid_with_placed_configuration, ObjectHelper<solid_with_shape_element_pattern,1> { solid_with_shape_element_pattern() : Object("solid_with_shape_element_pattern") {}
+		Lazy< modified_solid_with_placed_configuration > replicated_element;
+    };
+
+    // C++ wrapper for solid_with_circular_pattern
+    struct solid_with_circular_pattern : solid_with_shape_element_pattern, ObjectHelper<solid_with_circular_pattern,4> { solid_with_circular_pattern() : Object("solid_with_circular_pattern") {}
+		positive_integer::Out replicate_count;
+		plane_angle_measure::Out angular_spacing;
+		BOOLEAN::Out radial_alignment;
+		Lazy< point > reference_point;
+    };
+
+    // C++ wrapper for solid_with_depression
+    struct solid_with_depression : modified_solid_with_placed_configuration, ObjectHelper<solid_with_depression,1> { solid_with_depression() : Object("solid_with_depression") {}
+		positive_length_measure::Out depth;
+    };
+
+    // C++ wrapper for solid_with_pocket
+    struct solid_with_pocket : solid_with_depression, ObjectHelper<solid_with_pocket,2> { solid_with_pocket() : Object("solid_with_pocket") {}
+		non_negative_length_measure::Out floor_blend_radius;
+		plane_angle_measure::Out draft_angle;
+    };
+
+    // C++ wrapper for solid_with_circular_pocket
+    struct solid_with_circular_pocket : solid_with_pocket, ObjectHelper<solid_with_circular_pocket,1> { solid_with_circular_pocket() : Object("solid_with_circular_pocket") {}
+		positive_length_measure::Out pocket_radius;
+    };
+
+    // C++ wrapper for solid_with_protrusion
+    struct solid_with_protrusion : modified_solid_with_placed_configuration, ObjectHelper<solid_with_protrusion,2> { solid_with_protrusion() : Object("solid_with_protrusion") {}
+		positive_length_measure::Out protrusion_height;
+		plane_angle_measure::Out protrusion_draft_angle;
+    };
+
+    // C++ wrapper for solid_with_circular_protrusion
+    struct solid_with_circular_protrusion : solid_with_protrusion, ObjectHelper<solid_with_circular_protrusion,1> { solid_with_circular_protrusion() : Object("solid_with_circular_protrusion") {}
+		positive_length_measure::Out protrusion_radius;
+    };
+
+    // C++ wrapper for solid_with_hole
+    struct solid_with_hole : solid_with_depression, ObjectHelper<solid_with_hole,0> { solid_with_hole() : Object("solid_with_hole") {}
+
+    };
+
+    // C++ wrapper for solid_with_stepped_round_hole
+    struct solid_with_stepped_round_hole : solid_with_hole, ObjectHelper<solid_with_stepped_round_hole,1> { solid_with_stepped_round_hole() : Object("solid_with_stepped_round_hole") {}
+		positive_integer::Out segments;
+    };
+
+    // C++ wrapper for solid_with_conical_bottom_round_hole
+    struct solid_with_conical_bottom_round_hole : solid_with_stepped_round_hole, ObjectHelper<solid_with_conical_bottom_round_hole,2> { solid_with_conical_bottom_round_hole() : Object("solid_with_conical_bottom_round_hole") {}
+		positive_plane_angle_measure::Out semi_apex_angle;
+		non_negative_length_measure::Out tip_radius;
+    };
+
+    // C++ wrapper for solid_with_constant_radius_edge_blend
+    struct solid_with_constant_radius_edge_blend : edge_blended_solid, ObjectHelper<solid_with_constant_radius_edge_blend,1> { solid_with_constant_radius_edge_blend() : Object("solid_with_constant_radius_edge_blend") {}
+		positive_length_measure::Out radius;
+    };
+
+    // C++ wrapper for solid_with_slot
+    struct solid_with_slot : solid_with_depression, ObjectHelper<solid_with_slot,2> { solid_with_slot() : Object("solid_with_slot") {}
+		positive_length_measure::Out slot_width;
+		ListOf< LOGICAL, 2, 2 >::Out closed_ends;
+    };
+
+    // C++ wrapper for solid_with_curved_slot
+    struct solid_with_curved_slot : solid_with_slot, ObjectHelper<solid_with_curved_slot,1> { solid_with_curved_slot() : Object("solid_with_curved_slot") {}
+		Lazy< bounded_curve > slot_centreline;
+    };
+
+    // C++ wrapper for solid_with_double_offset_chamfer
+    struct solid_with_double_offset_chamfer : solid_with_chamfered_edges, ObjectHelper<solid_with_double_offset_chamfer,2> { solid_with_double_offset_chamfer() : Object("solid_with_double_offset_chamfer") {}
+		positive_length_measure::Out left_offset_distance;
+		positive_length_measure::Out right_offset_distance;
+    };
+
+    // C++ wrapper for solid_with_flat_bottom_round_hole
+    struct solid_with_flat_bottom_round_hole : solid_with_stepped_round_hole, ObjectHelper<solid_with_flat_bottom_round_hole,1> { solid_with_flat_bottom_round_hole() : Object("solid_with_flat_bottom_round_hole") {}
+		non_negative_length_measure::Out fillet_radius;
+    };
+
+    // C++ wrapper for solid_with_general_pocket
+    struct solid_with_general_pocket : solid_with_pocket, ObjectHelper<solid_with_general_pocket,2> { solid_with_general_pocket() : Object("solid_with_general_pocket") {}
+		Lazy< positioned_sketch > profile;
+		Lazy< point > reference_point;
+    };
+
+    // C++ wrapper for solid_with_general_protrusion
+    struct solid_with_general_protrusion : solid_with_protrusion, ObjectHelper<solid_with_general_protrusion,2> { solid_with_general_protrusion() : Object("solid_with_general_protrusion") {}
+		Lazy< positioned_sketch > profile;
+		Lazy< point > reference_point;
+    };
+
+    // C++ wrapper for solid_with_groove
+    struct solid_with_groove : solid_with_depression, ObjectHelper<solid_with_groove,5> { solid_with_groove() : Object("solid_with_groove") {}
+		positive_length_measure::Out groove_radius;
+		positive_length_measure::Out groove_width;
+		plane_angle_measure::Out draft_angle;
+		non_negative_length_measure::Out floor_fillet_radius;
+		BOOLEAN::Out external_groove;
+    };
+
+    // C++ wrapper for solid_with_incomplete_circular_pattern
+    struct solid_with_incomplete_circular_pattern : solid_with_circular_pattern, ObjectHelper<solid_with_incomplete_circular_pattern,1> { solid_with_incomplete_circular_pattern() : Object("solid_with_incomplete_circular_pattern") {}
+		ListOf< positive_integer, 1, 0 >::Out omitted_instances;
+    };
+
+    // C++ wrapper for solid_with_rectangular_pattern
+    struct solid_with_rectangular_pattern : solid_with_shape_element_pattern, ObjectHelper<solid_with_rectangular_pattern,4> { solid_with_rectangular_pattern() : Object("solid_with_rectangular_pattern") {}
+		positive_integer::Out row_count;
+		positive_integer::Out column_count;
+		length_measure::Out row_spacing;
+		length_measure::Out column_spacing;
+    };
+
+    // C++ wrapper for solid_with_incomplete_rectangular_pattern
+    struct solid_with_incomplete_rectangular_pattern : solid_with_rectangular_pattern, ObjectHelper<solid_with_incomplete_rectangular_pattern,0> { solid_with_incomplete_rectangular_pattern() : Object("solid_with_incomplete_rectangular_pattern") {}
+
+    };
+
+    // C++ wrapper for solid_with_rectangular_pocket
+    struct solid_with_rectangular_pocket : solid_with_pocket, ObjectHelper<solid_with_rectangular_pocket,3> { solid_with_rectangular_pocket() : Object("solid_with_rectangular_pocket") {}
+		positive_length_measure::Out pocket_length;
+		positive_length_measure::Out pocket_width;
+		non_negative_length_measure::Out corner_radius;
+    };
+
+    // C++ wrapper for solid_with_rectangular_protrusion
+    struct solid_with_rectangular_protrusion : solid_with_protrusion, ObjectHelper<solid_with_rectangular_protrusion,3> { solid_with_rectangular_protrusion() : Object("solid_with_rectangular_protrusion") {}
+		positive_length_measure::Out protrusion_length;
+		positive_length_measure::Out protrusion_width;
+		non_negative_length_measure::Out protrusion_corner_radius;
+    };
+
+    // C++ wrapper for solid_with_single_offset_chamfer
+    struct solid_with_single_offset_chamfer : solid_with_chamfered_edges, ObjectHelper<solid_with_single_offset_chamfer,1> { solid_with_single_offset_chamfer() : Object("solid_with_single_offset_chamfer") {}
+		positive_length_measure::Out offset_distance;
+    };
+
+    // C++ wrapper for solid_with_spherical_bottom_round_hole
+    struct solid_with_spherical_bottom_round_hole : solid_with_stepped_round_hole, ObjectHelper<solid_with_spherical_bottom_round_hole,1> { solid_with_spherical_bottom_round_hole() : Object("solid_with_spherical_bottom_round_hole") {}
+		positive_length_measure::Out sphere_radius;
+    };
+
+    // C++ wrapper for solid_with_stepped_round_hole_and_conical_transitions
+    struct solid_with_stepped_round_hole_and_conical_transitions : solid_with_stepped_round_hole, ObjectHelper<solid_with_stepped_round_hole_and_conical_transitions,1> { solid_with_stepped_round_hole_and_conical_transitions() : Object("solid_with_stepped_round_hole_and_conical_transitions") {}
+		ListOf< Lazy< conical_stepped_hole_transition >, 1, 0 > conical_transitions;
+    };
+
+    // C++ wrapper for solid_with_straight_slot
+    struct solid_with_straight_slot : solid_with_slot, ObjectHelper<solid_with_straight_slot,1> { solid_with_straight_slot() : Object("solid_with_straight_slot") {}
+		positive_length_measure::Out slot_length;
+    };
+
+    // C++ wrapper for solid_with_tee_section_slot
+    struct solid_with_tee_section_slot : solid_with_slot, ObjectHelper<solid_with_tee_section_slot,2> { solid_with_tee_section_slot() : Object("solid_with_tee_section_slot") {}
+		positive_length_measure::Out tee_section_width;
+		positive_length_measure::Out collar_depth;
+    };
+
+    // C++ wrapper for solid_with_through_depression
+    struct solid_with_through_depression : solid_with_depression, ObjectHelper<solid_with_through_depression,1> { solid_with_through_depression() : Object("solid_with_through_depression") {}
+		ListOf< Lazy< face_surface >, 1, 0 > exit_faces;
+    };
+
+    // C++ wrapper for solid_with_trapezoidal_section_slot
+    struct solid_with_trapezoidal_section_slot : solid_with_slot, ObjectHelper<solid_with_trapezoidal_section_slot,2> { solid_with_trapezoidal_section_slot() : Object("solid_with_trapezoidal_section_slot") {}
+		plane_angle_measure::Out draft_angle;
+		non_negative_length_measure::Out floor_fillet_radius;
+    };
+
+    // C++ wrapper for solid_with_variable_radius_edge_blend
+    struct solid_with_variable_radius_edge_blend :  ObjectHelper<solid_with_variable_radius_edge_blend,3> { solid_with_variable_radius_edge_blend() : Object("solid_with_variable_radius_edge_blend") {}
+		ListOf< Lazy< point >, 2, 0 > point_list;
+		ListOf< positive_length_measure, 2, 0 >::Out radius_list;
+		ListOf< blend_radius_variation_type, 1, 0 >::Out edge_function_list;
+    };
+
+    // C++ wrapper for source_for_requirement
+    struct source_for_requirement : group_assignment, ObjectHelper<source_for_requirement,1> { source_for_requirement() : Object("source_for_requirement") {}
+		ListOf< requirement_source_item, 1, 1 >::Out items;
+    };
+
+    // C++ wrapper for sourced_requirement
+    struct sourced_requirement : group_assignment, ObjectHelper<sourced_requirement,1> { sourced_requirement() : Object("sourced_requirement") {}
+		ListOf< Lazy< product_definition >, 1, 1 > items;
+    };
+
+    // C++ wrapper for specification_definition
+    struct specification_definition : product_definition, ObjectHelper<specification_definition,0> { specification_definition() : Object("specification_definition") {}
+
+    };
+
+    // C++ wrapper for specified_higher_usage_occurrence
+    struct specified_higher_usage_occurrence : assembly_component_usage, ObjectHelper<specified_higher_usage_occurrence,2> { specified_higher_usage_occurrence() : Object("specified_higher_usage_occurrence") {}
+		Lazy< assembly_component_usage > upper_usage;
+		Lazy< next_assembly_usage_occurrence > next_usage;
+    };
+
+    // C++ wrapper for sphere
+    struct sphere : geometric_representation_item, ObjectHelper<sphere,2> { sphere() : Object("sphere") {}
+		positive_length_measure::Out radius;
+		Lazy< point > centre;
+    };
+
+    // C++ wrapper for spherical_surface
+    struct spherical_surface : elementary_surface, ObjectHelper<spherical_surface,1> { spherical_surface() : Object("spherical_surface") {}
+		positive_length_measure::Out radius;
+    };
+
+    // C++ wrapper for start_request
+    struct start_request : action_request_assignment, ObjectHelper<start_request,1> { start_request() : Object("start_request") {}
+		ListOf< start_request_item, 1, 0 >::Out items;
+    };
+
+    // C++ wrapper for start_work
+    struct start_work : action_assignment, ObjectHelper<start_work,1> { start_work() : Object("start_work") {}
+		ListOf< work_item, 1, 0 >::Out items;
+    };
+
+    // C++ wrapper for straightness_tolerance
+    struct straightness_tolerance : geometric_tolerance, ObjectHelper<straightness_tolerance,0> { straightness_tolerance() : Object("straightness_tolerance") {}
+
+    };
+
+    // C++ wrapper for structured_dimension_callout
+    struct structured_dimension_callout : draughting_callout, ObjectHelper<structured_dimension_callout,0> { structured_dimension_callout() : Object("structured_dimension_callout") {}
+
+    };
+
+    // C++ wrapper for structured_text_composition
+    struct structured_text_composition : compound_representation_item, ObjectHelper<structured_text_composition,0> { structured_text_composition() : Object("structured_text_composition") {}
+
+    };
+
+    // C++ wrapper for structured_text_representation
+    struct structured_text_representation : representation, ObjectHelper<structured_text_representation,0> { structured_text_representation() : Object("structured_text_representation") {}
+
+    };
+
+    // C++ wrapper for subedge
+    struct subedge : edge, ObjectHelper<subedge,1> { subedge() : Object("subedge") {}
+		Lazy< edge > parent_edge;
+    };
+
+    // C++ wrapper for subface
+    struct subface : face, ObjectHelper<subface,1> { subface() : Object("subface") {}
+		Lazy< face > parent_face;
+    };
+
+    // C++ wrapper for supplied_part_relationship
+    struct supplied_part_relationship : product_definition_relationship, ObjectHelper<supplied_part_relationship,0> { supplied_part_relationship() : Object("supplied_part_relationship") {}
+
+    };
+
+    // C++ wrapper for surface_condition_callout
+    struct surface_condition_callout : draughting_callout, ObjectHelper<surface_condition_callout,0> { surface_condition_callout() : Object("surface_condition_callout") {}
+
+    };
+
+    // C++ wrapper for swept_surface
+    struct swept_surface : surface, ObjectHelper<swept_surface,1> { swept_surface() : Object("swept_surface") {}
+		Lazy< curve > swept_curve;
+    };
+
+    // C++ wrapper for surface_of_linear_extrusion
+    struct surface_of_linear_extrusion : swept_surface, ObjectHelper<surface_of_linear_extrusion,1> { surface_of_linear_extrusion() : Object("surface_of_linear_extrusion") {}
+		Lazy< vector > extrusion_axis;
+    };
+
+    // C++ wrapper for surface_of_revolution
+    struct surface_of_revolution : swept_surface, ObjectHelper<surface_of_revolution,1> { surface_of_revolution() : Object("surface_of_revolution") {}
+		Lazy< axis1_placement > axis_position;
+    };
+
+    // C++ wrapper for surface_patch
+    struct surface_patch : founded_item, ObjectHelper<surface_patch,5> { surface_patch() : Object("surface_patch") {}
+		Lazy< bounded_surface > parent_surface;
+		transition_code::Out u_transition;
+		transition_code::Out v_transition;
+		BOOLEAN::Out u_sense;
+		BOOLEAN::Out v_sense;
+    };
+
+    // C++ wrapper for surface_profile_tolerance
+    struct surface_profile_tolerance : geometric_tolerance, ObjectHelper<surface_profile_tolerance,0> { surface_profile_tolerance() : Object("surface_profile_tolerance") {}
+
+    };
+
+    // C++ wrapper for surface_replica
+    struct surface_replica : surface, ObjectHelper<surface_replica,2> { surface_replica() : Object("surface_replica") {}
+		Lazy< surface > parent_surface;
+		Lazy< cartesian_transformation_operator_3d > transformation;
+    };
+
+    // C++ wrapper for surface_side_style
+    struct surface_side_style : founded_item, ObjectHelper<surface_side_style,2> { surface_side_style() : Object("surface_side_style") {}
+		label::Out name;
+		ListOf< surface_style_element_select, 1, 7 >::Out styles;
+    };
+
+    // C++ wrapper for surface_style_boundary
+    struct surface_style_boundary : founded_item, ObjectHelper<surface_style_boundary,1> { surface_style_boundary() : Object("surface_style_boundary") {}
+		curve_or_render::Out style_of_boundary;
+    };
+
+    // C++ wrapper for surface_style_control_grid
+    struct surface_style_control_grid : founded_item, ObjectHelper<surface_style_control_grid,1> { surface_style_control_grid() : Object("surface_style_control_grid") {}
+		curve_or_render::Out style_of_control_grid;
+    };
+
+    // C++ wrapper for surface_style_fill_area
+    struct surface_style_fill_area : founded_item, ObjectHelper<surface_style_fill_area,1> { surface_style_fill_area() : Object("surface_style_fill_area") {}
+		Lazy< fill_area_style > fill_area;
+    };
+
+    // C++ wrapper for surface_style_parameter_line
+    struct surface_style_parameter_line : founded_item, ObjectHelper<surface_style_parameter_line,2> { surface_style_parameter_line() : Object("surface_style_parameter_line") {}
+		curve_or_render::Out style_of_parameter_lines;
+		ListOf< direction_count_select, 1, 2 >::Out direction_counts;
+    };
+
+    // C++ wrapper for surface_style_reflectance_ambient
+    struct surface_style_reflectance_ambient :  ObjectHelper<surface_style_reflectance_ambient,1> { surface_style_reflectance_ambient() : Object("surface_style_reflectance_ambient") {}
+		REAL::Out ambient_reflectance;
+    };
+
+    // C++ wrapper for surface_style_reflectance_ambient_diffuse
+    struct surface_style_reflectance_ambient_diffuse : surface_style_reflectance_ambient, ObjectHelper<surface_style_reflectance_ambient_diffuse,1> { surface_style_reflectance_ambient_diffuse() : Object("surface_style_reflectance_ambient_diffuse") {}
+		REAL::Out diffuse_reflectance;
+    };
+
+    // C++ wrapper for surface_style_reflectance_ambient_diffuse_specular
+    struct surface_style_reflectance_ambient_diffuse_specular : surface_style_reflectance_ambient_diffuse, ObjectHelper<surface_style_reflectance_ambient_diffuse_specular,3> { surface_style_reflectance_ambient_diffuse_specular() : Object("surface_style_reflectance_ambient_diffuse_specular") {}
+		REAL::Out specular_reflectance;
+		REAL::Out specular_exponent;
+		Lazy< colour > specular_colour;
+    };
+
+    // C++ wrapper for surface_style_rendering
+    struct surface_style_rendering :  ObjectHelper<surface_style_rendering,2> { surface_style_rendering() : Object("surface_style_rendering") {}
+		shading_surface_method::Out rendering_method;
+		Lazy< colour > surface_colour;
+    };
+
+    // C++ wrapper for surface_style_rendering_with_properties
+    struct surface_style_rendering_with_properties : surface_style_rendering, ObjectHelper<surface_style_rendering_with_properties,1> { surface_style_rendering_with_properties() : Object("surface_style_rendering_with_properties") {}
+		ListOf< rendering_properties_select, 1, 2 >::Out properties;
+    };
+
+    // C++ wrapper for surface_style_segmentation_curve
+    struct surface_style_segmentation_curve : founded_item, ObjectHelper<surface_style_segmentation_curve,1> { surface_style_segmentation_curve() : Object("surface_style_segmentation_curve") {}
+		curve_or_render::Out style_of_segmentation_curve;
+    };
+
+    // C++ wrapper for surface_style_silhouette
+    struct surface_style_silhouette : founded_item, ObjectHelper<surface_style_silhouette,1> { surface_style_silhouette() : Object("surface_style_silhouette") {}
+		curve_or_render::Out style_of_silhouette;
+    };
+
+    // C++ wrapper for surface_style_usage
+    struct surface_style_usage : founded_item, ObjectHelper<surface_style_usage,2> { surface_style_usage() : Object("surface_style_usage") {}
+		surface_side::Out side;
+		surface_side_style_select::Out style;
+    };
+
+    // C++ wrapper for surface_texture_representation
+    struct surface_texture_representation : representation, ObjectHelper<surface_texture_representation,0> { surface_texture_representation() : Object("surface_texture_representation") {}
+
+    };
+
+    // C++ wrapper for surfaced_open_shell
+    struct surfaced_open_shell : open_shell, ObjectHelper<surfaced_open_shell,0> { surfaced_open_shell() : Object("surfaced_open_shell") {}
+
+    };
+
+    // C++ wrapper for swept_disk_solid
+    struct swept_disk_solid : solid_model, ObjectHelper<swept_disk_solid,5> { swept_disk_solid() : Object("swept_disk_solid") {}
+		Lazy< curve > directrix;
+		positive_length_measure::Out radius;
+		Maybe< positive_length_measure::Out > inner_radius;
+		REAL::Out start_param;
+		REAL::Out end_param;
+    };
+
+    // C++ wrapper for symbol
+    struct symbol : representation_item, ObjectHelper<symbol,0> { symbol() : Object("symbol") {}
+
+    };
+
+    // C++ wrapper for symbol_representation_map
+    struct symbol_representation_map : representation_map, ObjectHelper<symbol_representation_map,0> { symbol_representation_map() : Object("symbol_representation_map") {}
+
+    };
+
+    // C++ wrapper for symbol_style
+    struct symbol_style : founded_item, ObjectHelper<symbol_style,2> { symbol_style() : Object("symbol_style") {}
+		label::Out name;
+		symbol_style_select::Out style_of_symbol;
+    };
+
+    // C++ wrapper for symbol_target
+    struct symbol_target : geometric_representation_item, ObjectHelper<symbol_target,3> { symbol_target() : Object("symbol_target") {}
+		axis2_placement::Out placement;
+		positive_ratio_measure::Out x_scale;
+		positive_ratio_measure::Out y_scale;
+    };
+
+    // C++ wrapper for symmetric_shape_aspect
+    struct symmetric_shape_aspect : shape_aspect, ObjectHelper<symmetric_shape_aspect,0> { symmetric_shape_aspect() : Object("symmetric_shape_aspect") {}
+
+    };
+
+    // C++ wrapper for symmetry_tolerance
+    struct symmetry_tolerance : geometric_tolerance_with_datum_reference, ObjectHelper<symmetry_tolerance,0> { symmetry_tolerance() : Object("symmetry_tolerance") {}
+
+    };
+
+    // C++ wrapper for table_representation_item
+    struct table_representation_item : compound_representation_item, ObjectHelper<table_representation_item,0> { table_representation_item() : Object("table_representation_item") {}
+
+    };
+
+    // C++ wrapper for tactile_appearance_representation
+    struct tactile_appearance_representation : representation, ObjectHelper<tactile_appearance_representation,0> { tactile_appearance_representation() : Object("tactile_appearance_representation") {}
+
+    };
+
+    // C++ wrapper for tagged_text_format
+    struct tagged_text_format : representation_context, ObjectHelper<tagged_text_format,0> { tagged_text_format() : Object("tagged_text_format") {}
+
+    };
+
+    // C++ wrapper for tagged_text_item
+    struct tagged_text_item : descriptive_representation_item, ObjectHelper<tagged_text_item,0> { tagged_text_item() : Object("tagged_text_item") {}
+
+    };
+
+    // C++ wrapper for tangent
+    struct tangent : derived_shape_aspect, ObjectHelper<tangent,0> { tangent() : Object("tangent") {}
+
+    };
+
+    // C++ wrapper for text_literal_with_associated_curves
+    struct text_literal_with_associated_curves : text_literal, ObjectHelper<text_literal_with_associated_curves,1> { text_literal_with_associated_curves() : Object("text_literal_with_associated_curves") {}
+		ListOf< Lazy< curve >, 1, 0 > associated_curves;
+    };
+
+    // C++ wrapper for text_literal_with_blanking_box
+    struct text_literal_with_blanking_box : text_literal, ObjectHelper<text_literal_with_blanking_box,1> { text_literal_with_blanking_box() : Object("text_literal_with_blanking_box") {}
+		Lazy< planar_box > blanking;
+    };
+
+    // C++ wrapper for text_literal_with_extent
+    struct text_literal_with_extent : text_literal, ObjectHelper<text_literal_with_extent,1> { text_literal_with_extent() : Object("text_literal_with_extent") {}
+		Lazy< planar_extent > extent;
+    };
+
+    // C++ wrapper for text_string_representation
+    struct text_string_representation : representation, ObjectHelper<text_string_representation,0> { text_string_representation() : Object("text_string_representation") {}
+
+    };
+
+    // C++ wrapper for text_style
+    struct text_style : founded_item, ObjectHelper<text_style,2> { text_style() : Object("text_style") {}
+		label::Out name;
+		character_style_select::Out character_appearance;
+    };
+
+    // C++ wrapper for text_style_with_box_characteristics
+    struct text_style_with_box_characteristics : text_style, ObjectHelper<text_style_with_box_characteristics,1> { text_style_with_box_characteristics() : Object("text_style_with_box_characteristics") {}
+		ListOf< box_characteristic_select, 1, 4 >::Out characteristics;
+    };
+
+    // C++ wrapper for text_style_with_mirror
+    struct text_style_with_mirror : text_style, ObjectHelper<text_style_with_mirror,1> { text_style_with_mirror() : Object("text_style_with_mirror") {}
+		axis2_placement::Out mirror_placement;
+    };
+
+    // C++ wrapper for text_style_with_spacing
+    struct text_style_with_spacing : text_style, ObjectHelper<text_style_with_spacing,1> { text_style_with_spacing() : Object("text_style_with_spacing") {}
+		character_spacing_select::Out character_spacing;
+    };
+
+    // C++ wrapper for thermal_resistance_measure_with_unit
+    struct thermal_resistance_measure_with_unit : measure_with_unit, ObjectHelper<thermal_resistance_measure_with_unit,0> { thermal_resistance_measure_with_unit() : Object("thermal_resistance_measure_with_unit") {}
+
+    };
+
+    // C++ wrapper for thermal_resistance_unit
+    struct thermal_resistance_unit : derived_unit, ObjectHelper<thermal_resistance_unit,0> { thermal_resistance_unit() : Object("thermal_resistance_unit") {}
+
+    };
+
+    // C++ wrapper for thermodynamic_temperature_measure_with_unit
+    struct thermodynamic_temperature_measure_with_unit : measure_with_unit, ObjectHelper<thermodynamic_temperature_measure_with_unit,0> { thermodynamic_temperature_measure_with_unit() : Object("thermodynamic_temperature_measure_with_unit") {}
+
+    };
+
+    // C++ wrapper for thermodynamic_temperature_unit
+    struct thermodynamic_temperature_unit : named_unit, ObjectHelper<thermodynamic_temperature_unit,0> { thermodynamic_temperature_unit() : Object("thermodynamic_temperature_unit") {}
+
+    };
+
+    // C++ wrapper for thickened_face_solid
+    struct thickened_face_solid : solid_model, ObjectHelper<thickened_face_solid,3> { thickened_face_solid() : Object("thickened_face_solid") {}
+		generalized_surface_select::Out base_element;
+		length_measure::Out offset1;
+		length_measure::Out offset2;
+    };
+
+    // C++ wrapper for thickness_laminate_definition
+    struct thickness_laminate_definition : product_definition, ObjectHelper<thickness_laminate_definition,0> { thickness_laminate_definition() : Object("thickness_laminate_definition") {}
+
+    };
+
+    // C++ wrapper for thickness_laminate_table
+    struct thickness_laminate_table : zone_structural_makeup, ObjectHelper<thickness_laminate_table,0> { thickness_laminate_table() : Object("thickness_laminate_table") {}
+
+    };
+
+    // C++ wrapper for time_interval
+    struct time_interval :  ObjectHelper<time_interval,3> { time_interval() : Object("time_interval") {}
+		identifier::Out id;
+		label::Out name;
+		Maybe< text::Out > description;
+    };
+
+    // C++ wrapper for time_interval_based_effectivity
+    struct time_interval_based_effectivity : effectivity, ObjectHelper<time_interval_based_effectivity,1> { time_interval_based_effectivity() : Object("time_interval_based_effectivity") {}
+		Lazy< time_interval > effectivity_period;
+    };
+
+    // C++ wrapper for time_interval_with_bounds
+    struct time_interval_with_bounds : time_interval, ObjectHelper<time_interval_with_bounds,3> { time_interval_with_bounds() : Object("time_interval_with_bounds") {}
+		Maybe< date_time_or_event_occurrence::Out > primary_bound;
+		Maybe< date_time_or_event_occurrence::Out > secondary_bound;
+		Maybe< Lazy< time_measure_with_unit > > duration;
+    };
+
+    // C++ wrapper for time_measure_with_unit
+    struct time_measure_with_unit : measure_with_unit, ObjectHelper<time_measure_with_unit,0> { time_measure_with_unit() : Object("time_measure_with_unit") {}
+
+    };
+
+    // C++ wrapper for time_unit
+    struct time_unit : named_unit, ObjectHelper<time_unit,0> { time_unit() : Object("time_unit") {}
+
+    };
+
+    // C++ wrapper for tolerance_zone
+    struct tolerance_zone : shape_aspect, ObjectHelper<tolerance_zone,2> { tolerance_zone() : Object("tolerance_zone") {}
+		ListOf< Lazy< geometric_tolerance >, 1, 0 > defining_tolerance;
+		Lazy< NotImplemented > form;
+    };
+
+    // C++ wrapper for torus
+    struct torus : geometric_representation_item, ObjectHelper<torus,3> { torus() : Object("torus") {}
+		Lazy< axis1_placement > position;
+		positive_length_measure::Out major_radius;
+		positive_length_measure::Out minor_radius;
+    };
+
+    // C++ wrapper for total_runout_tolerance
+    struct total_runout_tolerance : geometric_tolerance_with_datum_reference, ObjectHelper<total_runout_tolerance,0> { total_runout_tolerance() : Object("total_runout_tolerance") {}
+
+    };
+
+    // C++ wrapper for track_blended_solid
+    struct track_blended_solid : edge_blended_solid, ObjectHelper<track_blended_solid,0> { track_blended_solid() : Object("track_blended_solid") {}
+
+    };
+
+    // C++ wrapper for track_blended_solid_with_end_conditions
+    struct track_blended_solid_with_end_conditions : track_blended_solid, ObjectHelper<track_blended_solid_with_end_conditions,1> { track_blended_solid_with_end_conditions() : Object("track_blended_solid_with_end_conditions") {}
+		ListOf< blend_end_condition_select, 2, 2 >::Out end_conditions;
+    };
+
+    // C++ wrapper for trimmed_curve
+    struct trimmed_curve : bounded_curve, ObjectHelper<trimmed_curve,5> { trimmed_curve() : Object("trimmed_curve") {}
+		Lazy< curve > basis_curve;
+		ListOf< trimming_select, 1, 2 >::Out trim_1;
+		ListOf< trimming_select, 1, 2 >::Out trim_2;
+		BOOLEAN::Out sense_agreement;
+		trimming_preference::Out master_representation;
+    };
+
+    // C++ wrapper for two_direction_repeat_factor
+    struct two_direction_repeat_factor : one_direction_repeat_factor, ObjectHelper<two_direction_repeat_factor,1> { two_direction_repeat_factor() : Object("two_direction_repeat_factor") {}
+		Lazy< vector > second_repeat_factor;
+    };
+
+    // C++ wrapper for unary_generic_expression
+    struct unary_generic_expression : generic_expression, ObjectHelper<unary_generic_expression,1> { unary_generic_expression() : Object("unary_generic_expression") {}
+		Lazy< generic_expression > operand;
+    };
+
+    // C++ wrapper for unary_numeric_expression
+    struct unary_numeric_expression :  ObjectHelper<unary_numeric_expression,0> { unary_numeric_expression() : Object("unary_numeric_expression") {}
+
+    };
+
+    // C++ wrapper for uncertainty_assigned_representation
+    struct uncertainty_assigned_representation : representation, ObjectHelper<uncertainty_assigned_representation,1> { uncertainty_assigned_representation() : Object("uncertainty_assigned_representation") {}
+		ListOf< Lazy< uncertainty_measure_with_unit >, 1, 0 > uncertainty;
+    };
+
+    // C++ wrapper for uncertainty_measure_with_unit
+    struct uncertainty_measure_with_unit : measure_with_unit, ObjectHelper<uncertainty_measure_with_unit,2> { uncertainty_measure_with_unit() : Object("uncertainty_measure_with_unit") {}
+		label::Out name;
+		Maybe< text::Out > description;
+    };
+
+    // C++ wrapper for uniform_curve
+    struct uniform_curve : b_spline_curve, ObjectHelper<uniform_curve,0> { uniform_curve() : Object("uniform_curve") {}
+
+    };
+
+    // C++ wrapper for uniform_resource_identifier
+    struct uniform_resource_identifier : descriptive_representation_item, ObjectHelper<uniform_resource_identifier,0> { uniform_resource_identifier() : Object("uniform_resource_identifier") {}
+
+    };
+
+    // C++ wrapper for uniform_surface
+    struct uniform_surface : b_spline_surface, ObjectHelper<uniform_surface,0> { uniform_surface() : Object("uniform_surface") {}
+
+    };
+
+    // C++ wrapper for usage_association
+    struct usage_association : action_method_relationship, ObjectHelper<usage_association,0> { usage_association() : Object("usage_association") {}
+
+    };
+
+    // C++ wrapper for user_defined_curve_font
+    struct user_defined_curve_font :  ObjectHelper<user_defined_curve_font,0> { user_defined_curve_font() : Object("user_defined_curve_font") {}
+
+    };
+
+    // C++ wrapper for user_defined_marker
+    struct user_defined_marker :  ObjectHelper<user_defined_marker,0> { user_defined_marker() : Object("user_defined_marker") {}
+
+    };
+
+    // C++ wrapper for user_defined_terminator_symbol
+    struct user_defined_terminator_symbol :  ObjectHelper<user_defined_terminator_symbol,0> { user_defined_terminator_symbol() : Object("user_defined_terminator_symbol") {}
+
+    };
+
+    // C++ wrapper for user_selected_shape_elements
+    struct user_selected_shape_elements : user_selected_elements, ObjectHelper<user_selected_shape_elements,0> { user_selected_shape_elements() : Object("user_selected_shape_elements") {}
+
+    };
+
+    // C++ wrapper for value_range
+    struct value_range : compound_representation_item, ObjectHelper<value_range,0> { value_range() : Object("value_range") {}
+
+    };
+
+    // C++ wrapper for value_representation_item
+    struct value_representation_item : representation_item, ObjectHelper<value_representation_item,1> { value_representation_item() : Object("value_representation_item") {}
+		measure_value::Out value_component;
+    };
+
+    // C++ wrapper for variable_semantics
+    struct variable_semantics :  ObjectHelper<variable_semantics,0> { variable_semantics() : Object("variable_semantics") {}
+
+    };
+
+    // C++ wrapper for variational_representation_item
+    struct variational_representation_item : representation_item, ObjectHelper<variational_representation_item,0> { variational_representation_item() : Object("variational_representation_item") {}
+
+    };
+
+    // C++ wrapper for vector
+    struct vector : geometric_representation_item, ObjectHelper<vector,2> { vector() : Object("vector") {}
+		Lazy< direction > orientation;
+		length_measure::Out magnitude;
+    };
+
+    // C++ wrapper for vector_style
+    struct vector_style :  ObjectHelper<vector_style,0> { vector_style() : Object("vector_style") {}
+
+    };
+
+    // C++ wrapper for velocity_measure_with_unit
+    struct velocity_measure_with_unit : measure_with_unit, ObjectHelper<velocity_measure_with_unit,0> { velocity_measure_with_unit() : Object("velocity_measure_with_unit") {}
+
+    };
+
+    // C++ wrapper for velocity_unit
+    struct velocity_unit : derived_unit, ObjectHelper<velocity_unit,0> { velocity_unit() : Object("velocity_unit") {}
+
+    };
+
+    // C++ wrapper for vertex
+    struct vertex : topological_representation_item, ObjectHelper<vertex,0> { vertex() : Object("vertex") {}
+
+    };
+
+    // C++ wrapper for vertex_loop
+    struct vertex_loop : loop, ObjectHelper<vertex_loop,1> { vertex_loop() : Object("vertex_loop") {}
+		Lazy< vertex > loop_vertex;
+    };
+
+    // C++ wrapper for vertex_point
+    struct vertex_point :  ObjectHelper<vertex_point,1> { vertex_point() : Object("vertex_point") {}
+		Lazy< point > vertex_geometry;
+    };
+
+    // C++ wrapper for vertex_shell
+    struct vertex_shell : topological_representation_item, ObjectHelper<vertex_shell,1> { vertex_shell() : Object("vertex_shell") {}
+		Lazy< vertex_loop > vertex_shell_extent;
+    };
+
+    // C++ wrapper for view_volume
+    struct view_volume : founded_item, ObjectHelper<view_volume,9> { view_volume() : Object("view_volume") {}
+		central_or_parallel::Out projection_type;
+		Lazy< cartesian_point > projection_point;
+		length_measure::Out view_plane_distance;
+		length_measure::Out front_plane_distance;
+		BOOLEAN::Out front_plane_clipping;
+		length_measure::Out back_plane_distance;
+		BOOLEAN::Out back_plane_clipping;
+		BOOLEAN::Out view_volume_sides_clipping;
+		Lazy< planar_box > view_window;
+    };
+
+    // C++ wrapper for visual_appearance_representation
+    struct visual_appearance_representation : representation, ObjectHelper<visual_appearance_representation,0> { visual_appearance_representation() : Object("visual_appearance_representation") {}
+
+    };
+
+    // C++ wrapper for volume_measure_with_unit
+    struct volume_measure_with_unit : measure_with_unit, ObjectHelper<volume_measure_with_unit,0> { volume_measure_with_unit() : Object("volume_measure_with_unit") {}
+
+    };
+
+    // C++ wrapper for volume_unit
+    struct volume_unit : derived_unit, ObjectHelper<volume_unit,0> { volume_unit() : Object("volume_unit") {}
+
+    };
+
+    // C++ wrapper for week_of_year_and_day_date
+    struct week_of_year_and_day_date : date, ObjectHelper<week_of_year_and_day_date,2> { week_of_year_and_day_date() : Object("week_of_year_and_day_date") {}
+		week_in_year_number::Out week_component;
+		Maybe< day_in_week_number::Out > day_component;
+    };
+
+    // C++ wrapper for wire_shell
+    struct wire_shell : topological_representation_item, ObjectHelper<wire_shell,1> { wire_shell() : Object("wire_shell") {}
+		ListOf< Lazy< loop >, 1, 0 > wire_shell_extent;
+    };
+
+    // C++ wrapper for year_month
+    struct year_month : date, ObjectHelper<year_month,1> { year_month() : Object("year_month") {}
+		month_in_year_number::Out month_component;
+    };
+
+	void GetSchema(EXPRESS::ConversionSchema& out);
+
+} //! StepFile
+namespace STEP {
+
+	// ******************************************************************************
+	// Converter stubs
+	// ******************************************************************************
+	
+#define DECL_CONV_STUB(type) template <> size_t GenericFill<StepFile::type>(const STEP::DB& db, const EXPRESS::LIST& params, StepFile::type* in)
+	
+	DECL_CONV_STUB(measure_with_unit);
+	DECL_CONV_STUB(absorbed_dose_measure_with_unit);
+	DECL_CONV_STUB(derived_unit);
+	DECL_CONV_STUB(absorbed_dose_unit);
+	DECL_CONV_STUB(abstract_variable);
+	DECL_CONV_STUB(acceleration_measure_with_unit);
+	DECL_CONV_STUB(acceleration_unit);
+	DECL_CONV_STUB(action);
+	DECL_CONV_STUB(action_assignment);
+	DECL_CONV_STUB(action_method);
+	DECL_CONV_STUB(action_method_assignment);
+	DECL_CONV_STUB(action_method_relationship);
+	DECL_CONV_STUB(action_request_assignment);
+	DECL_CONV_STUB(address);
+	DECL_CONV_STUB(representation);
+	DECL_CONV_STUB(shape_representation);
+	DECL_CONV_STUB(advanced_brep_shape_representation);
+	DECL_CONV_STUB(face_surface);
+	DECL_CONV_STUB(advanced_face);
+	DECL_CONV_STUB(amount_of_substance_measure_with_unit);
+	DECL_CONV_STUB(named_unit);
+	DECL_CONV_STUB(amount_of_substance_unit);
+	DECL_CONV_STUB(angle_direction_reference);
+	DECL_CONV_STUB(representation_item);
+	DECL_CONV_STUB(geometric_representation_item);
+	DECL_CONV_STUB(draughting_callout);
+	DECL_CONV_STUB(dimension_curve_directed_callout);
+	DECL_CONV_STUB(angular_dimension);
+	DECL_CONV_STUB(shape_aspect_relationship);
+	DECL_CONV_STUB(dimensional_location);
+	DECL_CONV_STUB(angular_location);
+	DECL_CONV_STUB(dimensional_size);
+	DECL_CONV_STUB(angular_size);
+	DECL_CONV_STUB(geometric_tolerance);
+	DECL_CONV_STUB(geometric_tolerance_with_datum_reference);
+	DECL_CONV_STUB(angularity_tolerance);
+	DECL_CONV_STUB(styled_item);
+	DECL_CONV_STUB(annotation_occurrence);
+	DECL_CONV_STUB(annotation_curve_occurrence);
+	DECL_CONV_STUB(annotation_fill_area);
+	DECL_CONV_STUB(annotation_fill_area_occurrence);
+	DECL_CONV_STUB(annotation_occurrence_relationship);
+	DECL_CONV_STUB(annotation_occurrence_associativity);
+	DECL_CONV_STUB(annotation_plane);
+	DECL_CONV_STUB(annotation_symbol_occurrence);
+	DECL_CONV_STUB(annotation_subfigure_occurrence);
+	DECL_CONV_STUB(mapped_item);
+	DECL_CONV_STUB(annotation_symbol);
+	DECL_CONV_STUB(annotation_text);
+	DECL_CONV_STUB(annotation_text_character);
+	DECL_CONV_STUB(annotation_text_occurrence);
+	DECL_CONV_STUB(shape_aspect);
+	DECL_CONV_STUB(derived_shape_aspect);
+	DECL_CONV_STUB(apex);
+	DECL_CONV_STUB(application_context_element);
+	DECL_CONV_STUB(applied_action_assignment);
+	DECL_CONV_STUB(applied_action_method_assignment);
+	DECL_CONV_STUB(applied_action_request_assignment);
+	DECL_CONV_STUB(approval_assignment);
+	DECL_CONV_STUB(applied_approval_assignment);
+	DECL_CONV_STUB(attribute_classification_assignment);
+	DECL_CONV_STUB(applied_attribute_classification_assignment);
+	DECL_CONV_STUB(certification_assignment);
+	DECL_CONV_STUB(applied_certification_assignment);
+	DECL_CONV_STUB(classification_assignment);
+	DECL_CONV_STUB(applied_classification_assignment);
+	DECL_CONV_STUB(contract_assignment);
+	DECL_CONV_STUB(applied_contract_assignment);
+	DECL_CONV_STUB(date_and_time_assignment);
+	DECL_CONV_STUB(applied_date_and_time_assignment);
+	DECL_CONV_STUB(date_assignment);
+	DECL_CONV_STUB(applied_date_assignment);
+	DECL_CONV_STUB(document_reference);
+	DECL_CONV_STUB(applied_document_reference);
+	DECL_CONV_STUB(document_usage_constraint_assignment);
+	DECL_CONV_STUB(applied_document_usage_constraint_assignment);
+	DECL_CONV_STUB(effectivity_assignment);
+	DECL_CONV_STUB(applied_effectivity_assignment);
+	DECL_CONV_STUB(event_occurrence_assignment);
+	DECL_CONV_STUB(applied_event_occurrence_assignment);
+	DECL_CONV_STUB(identification_assignment);
+	DECL_CONV_STUB(external_identification_assignment);
+	DECL_CONV_STUB(applied_external_identification_assignment);
+	DECL_CONV_STUB(group_assignment);
+	DECL_CONV_STUB(applied_group_assignment);
+	DECL_CONV_STUB(applied_identification_assignment);
+	DECL_CONV_STUB(name_assignment);
+	DECL_CONV_STUB(applied_name_assignment);
+	DECL_CONV_STUB(organization_assignment);
+	DECL_CONV_STUB(applied_organization_assignment);
+	DECL_CONV_STUB(organizational_project_assignment);
+	DECL_CONV_STUB(applied_organizational_project_assignment);
+	DECL_CONV_STUB(person_and_organization_assignment);
+	DECL_CONV_STUB(applied_person_and_organization_assignment);
+	DECL_CONV_STUB(presented_item);
+	DECL_CONV_STUB(applied_presented_item);
+	DECL_CONV_STUB(security_classification_assignment);
+	DECL_CONV_STUB(applied_security_classification_assignment);
+	DECL_CONV_STUB(time_interval_assignment);
+	DECL_CONV_STUB(applied_time_interval_assignment);
+	DECL_CONV_STUB(applied_usage_right);
+	DECL_CONV_STUB(area_in_set);
+	DECL_CONV_STUB(area_measure_with_unit);
+	DECL_CONV_STUB(area_unit);
+	DECL_CONV_STUB(product_definition_relationship);
+	DECL_CONV_STUB(product_definition_usage);
+	DECL_CONV_STUB(assembly_component_usage);
+	DECL_CONV_STUB(assigned_requirement);
+	DECL_CONV_STUB(compound_representation_item);
+	DECL_CONV_STUB(atomic_formula);
+	DECL_CONV_STUB(attribute_assertion);
+	DECL_CONV_STUB(attribute_language_assignment);
+	DECL_CONV_STUB(attribute_value_assignment);
+	DECL_CONV_STUB(auxiliary_geometric_representation_item);
+	DECL_CONV_STUB(placement);
+	DECL_CONV_STUB(axis1_placement);
+	DECL_CONV_STUB(axis2_placement_2d);
+	DECL_CONV_STUB(axis2_placement_3d);
+	DECL_CONV_STUB(curve);
+	DECL_CONV_STUB(bounded_curve);
+	DECL_CONV_STUB(b_spline_curve);
+	DECL_CONV_STUB(b_spline_curve_with_knots);
+	DECL_CONV_STUB(surface);
+	DECL_CONV_STUB(bounded_surface);
+	DECL_CONV_STUB(b_spline_surface);
+	DECL_CONV_STUB(b_spline_surface_with_knots);
+	DECL_CONV_STUB(product_definition);
+	DECL_CONV_STUB(rule_software_definition);
+	DECL_CONV_STUB(rule_definition);
+	DECL_CONV_STUB(back_chaining_rule);
+	DECL_CONV_STUB(back_chaining_rule_body);
+	DECL_CONV_STUB(colour);
+	DECL_CONV_STUB(background_colour);
+	DECL_CONV_STUB(beveled_sheet_representation);
+	DECL_CONV_STUB(bezier_curve);
+	DECL_CONV_STUB(bezier_surface);
+	DECL_CONV_STUB(generic_expression);
+	DECL_CONV_STUB(binary_generic_expression);
+	DECL_CONV_STUB(binary_numeric_expression);
+	DECL_CONV_STUB(binary_representation_item);
+	DECL_CONV_STUB(block);
+	DECL_CONV_STUB(expression);
+	DECL_CONV_STUB(boolean_expression);
+	DECL_CONV_STUB(boolean_literal);
+	DECL_CONV_STUB(boolean_representation_item);
+	DECL_CONV_STUB(boolean_result);
+	DECL_CONV_STUB(composite_curve);
+	DECL_CONV_STUB(composite_curve_on_surface);
+	DECL_CONV_STUB(boundary_curve);
+	DECL_CONV_STUB(bounded_pcurve);
+	DECL_CONV_STUB(bounded_surface_curve);
+	DECL_CONV_STUB(founded_item);
+	DECL_CONV_STUB(box_domain);
+	DECL_CONV_STUB(half_space_solid);
+	DECL_CONV_STUB(boxed_half_space);
+	DECL_CONV_STUB(breakdown_context);
+	DECL_CONV_STUB(breakdown_element_group_assignment);
+	DECL_CONV_STUB(breakdown_element_realization);
+	DECL_CONV_STUB(breakdown_element_usage);
+	DECL_CONV_STUB(breakdown_of);
+	DECL_CONV_STUB(solid_model);
+	DECL_CONV_STUB(manifold_solid_brep);
+	DECL_CONV_STUB(brep_with_voids);
+	DECL_CONV_STUB(bytes_representation_item);
+	DECL_CONV_STUB(date);
+	DECL_CONV_STUB(calendar_date);
+	DECL_CONV_STUB(camera_image);
+	DECL_CONV_STUB(camera_image_3d_with_scale);
+	DECL_CONV_STUB(camera_model);
+	DECL_CONV_STUB(camera_model_d3);
+	DECL_CONV_STUB(camera_model_d3_multi_clipping);
+	DECL_CONV_STUB(camera_model_d3_multi_clipping_intersection);
+	DECL_CONV_STUB(camera_model_d3_multi_clipping_union);
+	DECL_CONV_STUB(camera_model_d3_with_hlhsr);
+	DECL_CONV_STUB(camera_model_with_light_sources);
+	DECL_CONV_STUB(representation_map);
+	DECL_CONV_STUB(camera_usage);
+	DECL_CONV_STUB(capacitance_measure_with_unit);
+	DECL_CONV_STUB(capacitance_unit);
+	DECL_CONV_STUB(point);
+	DECL_CONV_STUB(cartesian_point);
+	DECL_CONV_STUB(cartesian_transformation_operator);
+	DECL_CONV_STUB(cartesian_transformation_operator_2d);
+	DECL_CONV_STUB(cartesian_transformation_operator_3d);
+	DECL_CONV_STUB(cc_design_approval);
+	DECL_CONV_STUB(cc_design_certification);
+	DECL_CONV_STUB(cc_design_contract);
+	DECL_CONV_STUB(cc_design_date_and_time_assignment);
+	DECL_CONV_STUB(cc_design_person_and_organization_assignment);
+	DECL_CONV_STUB(cc_design_security_classification);
+	DECL_CONV_STUB(cc_design_specification_reference);
+	DECL_CONV_STUB(celsius_temperature_measure_with_unit);
+	DECL_CONV_STUB(centre_of_symmetry);
+	DECL_CONV_STUB(change);
+	DECL_CONV_STUB(change_request);
+	DECL_CONV_STUB(character_glyph_style_outline);
+	DECL_CONV_STUB(character_glyph_style_stroke);
+	DECL_CONV_STUB(symbol_representation);
+	DECL_CONV_STUB(generic_character_glyph_symbol);
+	DECL_CONV_STUB(character_glyph_symbol);
+	DECL_CONV_STUB(character_glyph_symbol_outline);
+	DECL_CONV_STUB(character_glyph_symbol_stroke);
+	DECL_CONV_STUB(general_property);
+	DECL_CONV_STUB(characteristic_data_column_header);
+	DECL_CONV_STUB(general_property_relationship);
+	DECL_CONV_STUB(characteristic_data_column_header_link);
+	DECL_CONV_STUB(characteristic_data_table_header);
+	DECL_CONV_STUB(characteristic_data_table_header_decomposition);
+	DECL_CONV_STUB(group);
+	DECL_CONV_STUB(characteristic_type);
+	DECL_CONV_STUB(characterized_class);
+	DECL_CONV_STUB(characterized_object);
+	DECL_CONV_STUB(conic);
+	DECL_CONV_STUB(circle);
+	DECL_CONV_STUB(circular_runout_tolerance);
+	DECL_CONV_STUB(class_by_extension);
+	DECL_CONV_STUB(class_by_intension);
+	DECL_CONV_STUB(class_system);
+	DECL_CONV_STUB(effectivity_context_assignment);
+	DECL_CONV_STUB(class_usage_effectivity_context_assignment);
+	DECL_CONV_STUB(topological_representation_item);
+	DECL_CONV_STUB(connected_face_set);
+	DECL_CONV_STUB(closed_shell);
+	DECL_CONV_STUB(coaxiality_tolerance);
+	DECL_CONV_STUB(colour_specification);
+	DECL_CONV_STUB(colour_rgb);
+	DECL_CONV_STUB(common_datum);
+	DECL_CONV_STUB(comparison_expression);
+	DECL_CONV_STUB(complex_clause);
+	DECL_CONV_STUB(complex_conjunctive_clause);
+	DECL_CONV_STUB(complex_disjunctive_clause);
+	DECL_CONV_STUB(modified_solid);
+	DECL_CONV_STUB(shelled_solid);
+	DECL_CONV_STUB(complex_shelled_solid);
+	DECL_CONV_STUB(composite_assembly_definition);
+	DECL_CONV_STUB(composite_assembly_sequence_definition);
+	DECL_CONV_STUB(laminate_table);
+	DECL_CONV_STUB(part_laminate_table);
+	DECL_CONV_STUB(composite_assembly_table);
+	DECL_CONV_STUB(composite_curve_segment);
+	DECL_CONV_STUB(material_designation);
+	DECL_CONV_STUB(composite_material_designation);
+	DECL_CONV_STUB(composite_shape_aspect);
+	DECL_CONV_STUB(composite_sheet_representation);
+	DECL_CONV_STUB(composite_text);
+	DECL_CONV_STUB(composite_text_with_associated_curves);
+	DECL_CONV_STUB(composite_text_with_blanking_box);
+	DECL_CONV_STUB(composite_text_with_delineation);
+	DECL_CONV_STUB(composite_text_with_extent);
+	DECL_CONV_STUB(compound_shape_representation);
+	DECL_CONV_STUB(concentricity_tolerance);
+	DECL_CONV_STUB(concept_feature_relationship);
+	DECL_CONV_STUB(concept_feature_relationship_with_condition);
+	DECL_CONV_STUB(product_concept_feature);
+	DECL_CONV_STUB(conditional_concept_feature);
+	DECL_CONV_STUB(conductance_measure_with_unit);
+	DECL_CONV_STUB(conductance_unit);
+	DECL_CONV_STUB(configuration_item);
+	DECL_CONV_STUB(configurable_item);
+	DECL_CONV_STUB(effectivity);
+	DECL_CONV_STUB(product_definition_effectivity);
+	DECL_CONV_STUB(configuration_effectivity);
+	DECL_CONV_STUB(configuration_item_relationship);
+	DECL_CONV_STUB(configuration_item_hierarchical_relationship);
+	DECL_CONV_STUB(configuration_item_revision_sequence);
+	DECL_CONV_STUB(configured_effectivity_assignment);
+	DECL_CONV_STUB(configured_effectivity_context_assignment);
+	DECL_CONV_STUB(conical_stepped_hole_transition);
+	DECL_CONV_STUB(elementary_surface);
+	DECL_CONV_STUB(conical_surface);
+	DECL_CONV_STUB(connected_edge_set);
+	DECL_CONV_STUB(connected_face_sub_set);
+	DECL_CONV_STUB(constructive_geometry_representation);
+	DECL_CONV_STUB(representation_relationship);
+	DECL_CONV_STUB(constructive_geometry_representation_relationship);
+	DECL_CONV_STUB(contact_ratio_representation);
+	DECL_CONV_STUB(invisibility);
+	DECL_CONV_STUB(context_dependent_invisibility);
+	DECL_CONV_STUB(over_riding_styled_item);
+	DECL_CONV_STUB(context_dependent_over_riding_styled_item);
+	DECL_CONV_STUB(context_dependent_unit);
+	DECL_CONV_STUB(conversion_based_unit);
+	DECL_CONV_STUB(csg_shape_representation);
+	DECL_CONV_STUB(csg_solid);
+	DECL_CONV_STUB(currency);
+	DECL_CONV_STUB(currency_measure_with_unit);
+	DECL_CONV_STUB(curve_bounded_surface);
+	DECL_CONV_STUB(curve_dimension);
+	DECL_CONV_STUB(curve_replica);
+	DECL_CONV_STUB(curve_style);
+	DECL_CONV_STUB(curve_style_font);
+	DECL_CONV_STUB(curve_style_font_and_scaling);
+	DECL_CONV_STUB(curve_style_font_pattern);
+	DECL_CONV_STUB(curve_swept_solid_shape_representation);
+	DECL_CONV_STUB(cylindrical_surface);
+	DECL_CONV_STUB(cylindricity_tolerance);
+	DECL_CONV_STUB(date_representation_item);
+	DECL_CONV_STUB(date_time_representation_item);
+	DECL_CONV_STUB(dated_effectivity);
+	DECL_CONV_STUB(datum);
+	DECL_CONV_STUB(datum_feature);
+	DECL_CONV_STUB(datum_feature_callout);
+	DECL_CONV_STUB(datum_reference);
+	DECL_CONV_STUB(datum_target);
+	DECL_CONV_STUB(datum_target_callout);
+	DECL_CONV_STUB(default_tolerance_table);
+	DECL_CONV_STUB(default_tolerance_table_cell);
+	DECL_CONV_STUB(defined_symbol);
+	DECL_CONV_STUB(definitional_representation);
+	DECL_CONV_STUB(definitional_representation_relationship);
+	DECL_CONV_STUB(definitional_representation_relationship_with_same_context);
+	DECL_CONV_STUB(degenerate_pcurve);
+	DECL_CONV_STUB(toroidal_surface);
+	DECL_CONV_STUB(degenerate_toroidal_surface);
+	DECL_CONV_STUB(descriptive_representation_item);
+	DECL_CONV_STUB(product_definition_context);
+	DECL_CONV_STUB(design_context);
+	DECL_CONV_STUB(design_make_from_relationship);
+	DECL_CONV_STUB(diameter_dimension);
+	DECL_CONV_STUB(ratio_measure_with_unit);
+	DECL_CONV_STUB(dielectric_constant_measure_with_unit);
+	DECL_CONV_STUB(dimension_callout);
+	DECL_CONV_STUB(draughting_callout_relationship);
+	DECL_CONV_STUB(dimension_callout_component_relationship);
+	DECL_CONV_STUB(dimension_callout_relationship);
+	DECL_CONV_STUB(dimension_curve);
+	DECL_CONV_STUB(terminator_symbol);
+	DECL_CONV_STUB(dimension_curve_terminator);
+	DECL_CONV_STUB(dimension_curve_terminator_to_projection_curve_associativity);
+	DECL_CONV_STUB(dimension_pair);
+	DECL_CONV_STUB(dimension_text_associativity);
+	DECL_CONV_STUB(dimensional_location_with_path);
+	DECL_CONV_STUB(dimensional_size_with_path);
+	DECL_CONV_STUB(executed_action);
+	DECL_CONV_STUB(directed_action);
+	DECL_CONV_STUB(directed_dimensional_location);
+	DECL_CONV_STUB(direction);
+	DECL_CONV_STUB(document_file);
+	DECL_CONV_STUB(document_identifier);
+	DECL_CONV_STUB(document_identifier_assignment);
+	DECL_CONV_STUB(document_product_association);
+	DECL_CONV_STUB(document_product_equivalence);
+	DECL_CONV_STUB(dose_equivalent_measure_with_unit);
+	DECL_CONV_STUB(dose_equivalent_unit);
+	DECL_CONV_STUB(double_offset_shelled_solid);
+	DECL_CONV_STUB(item_defined_transformation);
+	DECL_CONV_STUB(transformation_with_derived_angle);
+	DECL_CONV_STUB(draped_defined_transformation);
+	DECL_CONV_STUB(draughting_annotation_occurrence);
+	DECL_CONV_STUB(draughting_elements);
+	DECL_CONV_STUB(draughting_model);
+	DECL_CONV_STUB(item_identified_representation_usage);
+	DECL_CONV_STUB(draughting_model_item_association);
+	DECL_CONV_STUB(pre_defined_colour);
+	DECL_CONV_STUB(draughting_pre_defined_colour);
+	DECL_CONV_STUB(pre_defined_item);
+	DECL_CONV_STUB(pre_defined_curve_font);
+	DECL_CONV_STUB(draughting_pre_defined_curve_font);
+	DECL_CONV_STUB(pre_defined_text_font);
+	DECL_CONV_STUB(draughting_pre_defined_text_font);
+	DECL_CONV_STUB(draughting_subfigure_representation);
+	DECL_CONV_STUB(draughting_symbol_representation);
+	DECL_CONV_STUB(text_literal);
+	DECL_CONV_STUB(text_literal_with_delineation);
+	DECL_CONV_STUB(draughting_text_literal_with_delineation);
+	DECL_CONV_STUB(presentation_set);
+	DECL_CONV_STUB(drawing_revision);
+	DECL_CONV_STUB(presentation_representation);
+	DECL_CONV_STUB(presentation_area);
+	DECL_CONV_STUB(drawing_sheet_revision);
+	DECL_CONV_STUB(drawing_sheet_revision_sequence);
+	DECL_CONV_STUB(drawing_sheet_revision_usage);
+	DECL_CONV_STUB(edge);
+	DECL_CONV_STUB(edge_based_wireframe_model);
+	DECL_CONV_STUB(edge_based_wireframe_shape_representation);
+	DECL_CONV_STUB(edge_blended_solid);
+	DECL_CONV_STUB(edge_curve);
+	DECL_CONV_STUB(edge_loop);
+	DECL_CONV_STUB(electric_charge_measure_with_unit);
+	DECL_CONV_STUB(electric_charge_unit);
+	DECL_CONV_STUB(electric_current_measure_with_unit);
+	DECL_CONV_STUB(electric_current_unit);
+	DECL_CONV_STUB(electric_potential_measure_with_unit);
+	DECL_CONV_STUB(electric_potential_unit);
+	DECL_CONV_STUB(elementary_brep_shape_representation);
+	DECL_CONV_STUB(ellipse);
+	DECL_CONV_STUB(energy_measure_with_unit);
+	DECL_CONV_STUB(energy_unit);
+	DECL_CONV_STUB(property_definition);
+	DECL_CONV_STUB(fact_type);
+	DECL_CONV_STUB(entity_assertion);
+	DECL_CONV_STUB(enum_reference_prefix);
+	DECL_CONV_STUB(evaluated_characteristic);
+	DECL_CONV_STUB(evaluated_degenerate_pcurve);
+	DECL_CONV_STUB(evaluation_product_definition);
+	DECL_CONV_STUB(event_occurrence);
+	DECL_CONV_STUB(product_concept_feature_category);
+	DECL_CONV_STUB(exclusive_product_concept_feature_category);
+	DECL_CONV_STUB(uncertainty_qualifier);
+	DECL_CONV_STUB(standard_uncertainty);
+	DECL_CONV_STUB(expanded_uncertainty);
+	DECL_CONV_STUB(representation_item_relationship);
+	DECL_CONV_STUB(explicit_procedural_representation_item_relationship);
+	DECL_CONV_STUB(explicit_procedural_geometric_representation_item_relationship);
+	DECL_CONV_STUB(explicit_procedural_representation_relationship);
+	DECL_CONV_STUB(explicit_procedural_shape_representation_relationship);
+	DECL_CONV_STUB(expression_conversion_based_unit);
+	DECL_CONV_STUB(extension);
+	DECL_CONV_STUB(extent);
+	DECL_CONV_STUB(external_source);
+	DECL_CONV_STUB(external_class_library);
+	DECL_CONV_STUB(externally_defined_class);
+	DECL_CONV_STUB(externally_defined_colour);
+	DECL_CONV_STUB(externally_defined_context_dependent_unit);
+	DECL_CONV_STUB(externally_defined_conversion_based_unit);
+	DECL_CONV_STUB(externally_defined_currency);
+	DECL_CONV_STUB(externally_defined_item);
+	DECL_CONV_STUB(externally_defined_curve_font);
+	DECL_CONV_STUB(externally_defined_dimension_definition);
+	DECL_CONV_STUB(externally_defined_general_property);
+	DECL_CONV_STUB(externally_defined_hatch_style);
+	DECL_CONV_STUB(externally_defined_marker);
+	DECL_CONV_STUB(picture_representation_item);
+	DECL_CONV_STUB(externally_defined_picture_representation_item);
+	DECL_CONV_STUB(externally_defined_representation_item);
+	DECL_CONV_STUB(externally_defined_string);
+	DECL_CONV_STUB(externally_defined_symbol);
+	DECL_CONV_STUB(externally_defined_terminator_symbol);
+	DECL_CONV_STUB(externally_defined_text_font);
+	DECL_CONV_STUB(externally_defined_tile);
+	DECL_CONV_STUB(externally_defined_tile_style);
+	DECL_CONV_STUB(swept_area_solid);
+	DECL_CONV_STUB(extruded_area_solid);
+	DECL_CONV_STUB(swept_face_solid);
+	DECL_CONV_STUB(extruded_face_solid);
+	DECL_CONV_STUB(extruded_face_solid_with_trim_conditions);
+	DECL_CONV_STUB(extruded_face_solid_with_draft_angle);
+	DECL_CONV_STUB(extruded_face_solid_with_multiple_draft_angles);
+	DECL_CONV_STUB(face);
+	DECL_CONV_STUB(face_based_surface_model);
+	DECL_CONV_STUB(face_bound);
+	DECL_CONV_STUB(face_outer_bound);
+	DECL_CONV_STUB(faceted_brep);
+	DECL_CONV_STUB(faceted_brep_shape_representation);
+	DECL_CONV_STUB(fill_area_style);
+	DECL_CONV_STUB(fill_area_style_hatching);
+	DECL_CONV_STUB(fill_area_style_tile_coloured_region);
+	DECL_CONV_STUB(fill_area_style_tile_curve_with_style);
+	DECL_CONV_STUB(fill_area_style_tile_symbol_with_style);
+	DECL_CONV_STUB(fill_area_style_tiles);
+	DECL_CONV_STUB(shape_representation_relationship);
+	DECL_CONV_STUB(flat_pattern_ply_representation_relationship);
+	DECL_CONV_STUB(flatness_tolerance);
+	DECL_CONV_STUB(force_measure_with_unit);
+	DECL_CONV_STUB(force_unit);
+	DECL_CONV_STUB(forward_chaining_rule);
+	DECL_CONV_STUB(forward_chaining_rule_premise);
+	DECL_CONV_STUB(frequency_measure_with_unit);
+	DECL_CONV_STUB(frequency_unit);
+	DECL_CONV_STUB(func);
+	DECL_CONV_STUB(functional_breakdown_context);
+	DECL_CONV_STUB(functional_element_usage);
+	DECL_CONV_STUB(general_material_property);
+	DECL_CONV_STUB(simple_generic_expression);
+	DECL_CONV_STUB(generic_literal);
+	DECL_CONV_STUB(generic_variable);
+	DECL_CONV_STUB(geometric_alignment);
+	DECL_CONV_STUB(geometric_set);
+	DECL_CONV_STUB(geometric_curve_set);
+	DECL_CONV_STUB(geometric_intersection);
+	DECL_CONV_STUB(geometric_item_specific_usage);
+	DECL_CONV_STUB(geometric_model_element_relationship);
+	DECL_CONV_STUB(representation_context);
+	DECL_CONV_STUB(geometric_representation_context);
+	DECL_CONV_STUB(geometric_tolerance_with_defined_unit);
+	DECL_CONV_STUB(geometrical_tolerance_callout);
+	DECL_CONV_STUB(geometrically_bounded_2d_wireframe_representation);
+	DECL_CONV_STUB(geometrically_bounded_surface_shape_representation);
+	DECL_CONV_STUB(geometrically_bounded_wireframe_shape_representation);
+	DECL_CONV_STUB(global_assignment);
+	DECL_CONV_STUB(global_uncertainty_assigned_context);
+	DECL_CONV_STUB(global_unit_assigned_context);
+	DECL_CONV_STUB(ground_fact);
+	DECL_CONV_STUB(hardness_representation);
+	DECL_CONV_STUB(hidden_element_over_riding_styled_item);
+	DECL_CONV_STUB(hyperbola);
+	DECL_CONV_STUB(illuminance_measure_with_unit);
+	DECL_CONV_STUB(illuminance_unit);
+	DECL_CONV_STUB(included_text_block);
+	DECL_CONV_STUB(inclusion_product_concept_feature);
+	DECL_CONV_STUB(user_selected_elements);
+	DECL_CONV_STUB(indirectly_selected_elements);
+	DECL_CONV_STUB(indirectly_selected_shape_elements);
+	DECL_CONV_STUB(inductance_measure_with_unit);
+	DECL_CONV_STUB(inductance_unit);
+	DECL_CONV_STUB(information_right);
+	DECL_CONV_STUB(information_usage_right);
+	DECL_CONV_STUB(instance_usage_context_assignment);
+	DECL_CONV_STUB(instanced_feature);
+	DECL_CONV_STUB(literal_number);
+	DECL_CONV_STUB(int_literal);
+	DECL_CONV_STUB(integer_representation_item);
+	DECL_CONV_STUB(surface_curve);
+	DECL_CONV_STUB(intersection_curve);
+	DECL_CONV_STUB(interval_expression);
+	DECL_CONV_STUB(iso4217_currency);
+	DECL_CONV_STUB(known_source);
+	DECL_CONV_STUB(laid_defined_transformation);
+	DECL_CONV_STUB(language);
+	DECL_CONV_STUB(leader_curve);
+	DECL_CONV_STUB(leader_directed_callout);
+	DECL_CONV_STUB(leader_directed_dimension);
+	DECL_CONV_STUB(leader_terminator);
+	DECL_CONV_STUB(length_measure_with_unit);
+	DECL_CONV_STUB(length_unit);
+	DECL_CONV_STUB(light_source);
+	DECL_CONV_STUB(light_source_ambient);
+	DECL_CONV_STUB(light_source_directional);
+	DECL_CONV_STUB(light_source_positional);
+	DECL_CONV_STUB(light_source_spot);
+	DECL_CONV_STUB(line);
+	DECL_CONV_STUB(line_profile_tolerance);
+	DECL_CONV_STUB(linear_dimension);
+	DECL_CONV_STUB(simple_clause);
+	DECL_CONV_STUB(literal_conjunction);
+	DECL_CONV_STUB(literal_disjunction);
+	DECL_CONV_STUB(logical_literal);
+	DECL_CONV_STUB(logical_representation_item);
+	DECL_CONV_STUB(loop);
+	DECL_CONV_STUB(loss_tangent_measure_with_unit);
+	DECL_CONV_STUB(lot_effectivity);
+	DECL_CONV_STUB(luminous_flux_measure_with_unit);
+	DECL_CONV_STUB(luminous_flux_unit);
+	DECL_CONV_STUB(luminous_intensity_measure_with_unit);
+	DECL_CONV_STUB(luminous_intensity_unit);
+	DECL_CONV_STUB(magnetic_flux_density_measure_with_unit);
+	DECL_CONV_STUB(magnetic_flux_density_unit);
+	DECL_CONV_STUB(magnetic_flux_measure_with_unit);
+	DECL_CONV_STUB(magnetic_flux_unit);
+	DECL_CONV_STUB(make_from_usage_option);
+	DECL_CONV_STUB(manifold_subsurface_shape_representation);
+	DECL_CONV_STUB(manifold_surface_shape_representation);
+	DECL_CONV_STUB(mass_measure_with_unit);
+	DECL_CONV_STUB(mass_unit);
+	DECL_CONV_STUB(material_property);
+	DECL_CONV_STUB(property_definition_representation);
+	DECL_CONV_STUB(material_property_representation);
+	DECL_CONV_STUB(measure_representation_item);
+	DECL_CONV_STUB(product_context);
+	DECL_CONV_STUB(mechanical_context);
+	DECL_CONV_STUB(mechanical_design_and_draughting_relationship);
+	DECL_CONV_STUB(mechanical_design_geometric_presentation_area);
+	DECL_CONV_STUB(mechanical_design_geometric_presentation_representation);
+	DECL_CONV_STUB(mechanical_design_presentation_representation_with_draughting);
+	DECL_CONV_STUB(mechanical_design_shaded_presentation_area);
+	DECL_CONV_STUB(mechanical_design_shaded_presentation_representation);
+	DECL_CONV_STUB(min_and_major_ply_orientation_basis);
+	DECL_CONV_STUB(modified_geometric_tolerance);
+	DECL_CONV_STUB(modified_solid_with_placed_configuration);
+	DECL_CONV_STUB(moments_of_inertia_representation);
+	DECL_CONV_STUB(multi_language_attribute_assignment);
+	DECL_CONV_STUB(multiple_arity_boolean_expression);
+	DECL_CONV_STUB(multiple_arity_generic_expression);
+	DECL_CONV_STUB(multiple_arity_numeric_expression);
+	DECL_CONV_STUB(next_assembly_usage_occurrence);
+	DECL_CONV_STUB(non_manifold_surface_shape_representation);
+	DECL_CONV_STUB(null_representation_item);
+	DECL_CONV_STUB(numeric_expression);
+	DECL_CONV_STUB(offset_curve_2d);
+	DECL_CONV_STUB(offset_curve_3d);
+	DECL_CONV_STUB(offset_surface);
+	DECL_CONV_STUB(one_direction_repeat_factor);
+	DECL_CONV_STUB(open_shell);
+	DECL_CONV_STUB(ordinal_date);
+	DECL_CONV_STUB(projection_directed_callout);
+	DECL_CONV_STUB(ordinate_dimension);
+	DECL_CONV_STUB(organizational_address);
+	DECL_CONV_STUB(oriented_closed_shell);
+	DECL_CONV_STUB(oriented_edge);
+	DECL_CONV_STUB(oriented_face);
+	DECL_CONV_STUB(oriented_open_shell);
+	DECL_CONV_STUB(path);
+	DECL_CONV_STUB(oriented_path);
+	DECL_CONV_STUB(oriented_surface);
+	DECL_CONV_STUB(outer_boundary_curve);
+	DECL_CONV_STUB(package_product_concept_feature);
+	DECL_CONV_STUB(parabola);
+	DECL_CONV_STUB(parallel_offset);
+	DECL_CONV_STUB(parallelism_tolerance);
+	DECL_CONV_STUB(parametric_representation_context);
+	DECL_CONV_STUB(partial_document_with_structured_text_representation_assignment);
+	DECL_CONV_STUB(pcurve);
+	DECL_CONV_STUB(percentage_laminate_definition);
+	DECL_CONV_STUB(zone_structural_makeup);
+	DECL_CONV_STUB(percentage_laminate_table);
+	DECL_CONV_STUB(percentage_ply_definition);
+	DECL_CONV_STUB(perpendicular_to);
+	DECL_CONV_STUB(perpendicularity_tolerance);
+	DECL_CONV_STUB(person_and_organization_address);
+	DECL_CONV_STUB(personal_address);
+	DECL_CONV_STUB(physical_breakdown_context);
+	DECL_CONV_STUB(physical_element_usage);
+	DECL_CONV_STUB(presentation_view);
+	DECL_CONV_STUB(picture_representation);
+	DECL_CONV_STUB(placed_datum_target_feature);
+	DECL_CONV_STUB(placed_feature);
+	DECL_CONV_STUB(planar_extent);
+	DECL_CONV_STUB(planar_box);
+	DECL_CONV_STUB(plane);
+	DECL_CONV_STUB(plane_angle_measure_with_unit);
+	DECL_CONV_STUB(plane_angle_unit);
+	DECL_CONV_STUB(ply_laminate_definition);
+	DECL_CONV_STUB(ply_laminate_sequence_definition);
+	DECL_CONV_STUB(ply_laminate_table);
+	DECL_CONV_STUB(point_and_vector);
+	DECL_CONV_STUB(point_on_curve);
+	DECL_CONV_STUB(point_on_surface);
+	DECL_CONV_STUB(point_path);
+	DECL_CONV_STUB(point_replica);
+	DECL_CONV_STUB(point_style);
+	DECL_CONV_STUB(polar_complex_number_literal);
+	DECL_CONV_STUB(poly_loop);
+	DECL_CONV_STUB(polyline);
+	DECL_CONV_STUB(position_tolerance);
+	DECL_CONV_STUB(positioned_sketch);
+	DECL_CONV_STUB(power_measure_with_unit);
+	DECL_CONV_STUB(power_unit);
+	DECL_CONV_STUB(pre_defined_symbol);
+	DECL_CONV_STUB(pre_defined_dimension_symbol);
+	DECL_CONV_STUB(pre_defined_geometrical_tolerance_symbol);
+	DECL_CONV_STUB(pre_defined_marker);
+	DECL_CONV_STUB(pre_defined_point_marker_symbol);
+	DECL_CONV_STUB(pre_defined_surface_condition_symbol);
+	DECL_CONV_STUB(pre_defined_surface_side_style);
+	DECL_CONV_STUB(pre_defined_terminator_symbol);
+	DECL_CONV_STUB(pre_defined_tile);
+	DECL_CONV_STUB(predefined_picture_representation_item);
+	DECL_CONV_STUB(presentation_style_assignment);
+	DECL_CONV_STUB(presentation_style_by_context);
+	DECL_CONV_STUB(pressure_measure_with_unit);
+	DECL_CONV_STUB(pressure_unit);
+	DECL_CONV_STUB(procedural_representation);
+	DECL_CONV_STUB(procedural_representation_sequence);
+	DECL_CONV_STUB(procedural_shape_representation);
+	DECL_CONV_STUB(procedural_shape_representation_sequence);
+	DECL_CONV_STUB(product_category);
+	DECL_CONV_STUB(product_class);
+	DECL_CONV_STUB(product_concept_context);
+	DECL_CONV_STUB(product_concept_feature_category_usage);
+	DECL_CONV_STUB(product_definition_element_relationship);
+	DECL_CONV_STUB(product_definition_formation);
+	DECL_CONV_STUB(product_definition_formation_with_specified_source);
+	DECL_CONV_STUB(product_definition_group_assignment);
+	DECL_CONV_STUB(product_definition_shape);
+	DECL_CONV_STUB(product_definition_with_associated_documents);
+	DECL_CONV_STUB(product_identification);
+	DECL_CONV_STUB(product_material_composition_relationship);
+	DECL_CONV_STUB(product_related_product_category);
+	DECL_CONV_STUB(product_specification);
+	DECL_CONV_STUB(tolerance_zone_definition);
+	DECL_CONV_STUB(projected_zone_definition);
+	DECL_CONV_STUB(projection_curve);
+	DECL_CONV_STUB(promissory_usage_occurrence);
+	DECL_CONV_STUB(qualified_representation_item);
+	DECL_CONV_STUB(qualitative_uncertainty);
+	DECL_CONV_STUB(quantified_assembly_component_usage);
+	DECL_CONV_STUB(quasi_uniform_curve);
+	DECL_CONV_STUB(quasi_uniform_surface);
+	DECL_CONV_STUB(radioactivity_measure_with_unit);
+	DECL_CONV_STUB(radioactivity_unit);
+	DECL_CONV_STUB(radius_dimension);
+	DECL_CONV_STUB(range_characteristic);
+	DECL_CONV_STUB(ratio_unit);
+	DECL_CONV_STUB(rational_b_spline_curve);
+	DECL_CONV_STUB(rational_b_spline_surface);
+	DECL_CONV_STUB(rational_representation_item);
+	DECL_CONV_STUB(real_literal);
+	DECL_CONV_STUB(real_representation_item);
+	DECL_CONV_STUB(rectangular_composite_surface);
+	DECL_CONV_STUB(rectangular_trimmed_surface);
+	DECL_CONV_STUB(referenced_modified_datum);
+	DECL_CONV_STUB(relative_event_occurrence);
+	DECL_CONV_STUB(rep_item_group);
+	DECL_CONV_STUB(reparametrised_composite_curve_segment);
+	DECL_CONV_STUB(representation_relationship_with_transformation);
+	DECL_CONV_STUB(requirement_assigned_object);
+	DECL_CONV_STUB(requirement_assignment);
+	DECL_CONV_STUB(requirement_source);
+	DECL_CONV_STUB(requirement_view_definition_relationship);
+	DECL_CONV_STUB(resistance_measure_with_unit);
+	DECL_CONV_STUB(resistance_unit);
+	DECL_CONV_STUB(revolved_area_solid);
+	DECL_CONV_STUB(revolved_face_solid);
+	DECL_CONV_STUB(revolved_face_solid_with_trim_conditions);
+	DECL_CONV_STUB(right_angular_wedge);
+	DECL_CONV_STUB(right_circular_cone);
+	DECL_CONV_STUB(right_circular_cylinder);
+	DECL_CONV_STUB(right_to_usage_association);
+	DECL_CONV_STUB(roundness_tolerance);
+	DECL_CONV_STUB(row_representation_item);
+	DECL_CONV_STUB(row_value);
+	DECL_CONV_STUB(row_variable);
+	DECL_CONV_STUB(rule_action);
+	DECL_CONV_STUB(rule_condition);
+	DECL_CONV_STUB(rule_set);
+	DECL_CONV_STUB(rule_set_group);
+	DECL_CONV_STUB(rule_superseded_assignment);
+	DECL_CONV_STUB(rule_supersedence);
+	DECL_CONV_STUB(surface_curve_swept_area_solid);
+	DECL_CONV_STUB(ruled_surface_swept_area_solid);
+	DECL_CONV_STUB(runout_zone_definition);
+	DECL_CONV_STUB(runout_zone_orientation);
+	DECL_CONV_STUB(runout_zone_orientation_reference_direction);
+	DECL_CONV_STUB(satisfied_requirement);
+	DECL_CONV_STUB(satisfies_requirement);
+	DECL_CONV_STUB(satisfying_item);
+	DECL_CONV_STUB(scalar_variable);
+	DECL_CONV_STUB(scattering_parameter);
+	DECL_CONV_STUB(sculptured_solid);
+	DECL_CONV_STUB(seam_curve);
+	DECL_CONV_STUB(serial_numbered_effectivity);
+	DECL_CONV_STUB(shape_aspect_associativity);
+	DECL_CONV_STUB(shape_aspect_deriving_relationship);
+	DECL_CONV_STUB(shape_definition_representation);
+	DECL_CONV_STUB(shape_dimension_representation);
+	DECL_CONV_STUB(shape_feature_definition);
+	DECL_CONV_STUB(shape_representation_with_parameters);
+	DECL_CONV_STUB(shell_based_surface_model);
+	DECL_CONV_STUB(shell_based_wireframe_model);
+	DECL_CONV_STUB(shell_based_wireframe_shape_representation);
+	DECL_CONV_STUB(si_absorbed_dose_unit);
+	DECL_CONV_STUB(si_capacitance_unit);
+	DECL_CONV_STUB(si_conductance_unit);
+	DECL_CONV_STUB(si_dose_equivalent_unit);
+	DECL_CONV_STUB(si_electric_charge_unit);
+	DECL_CONV_STUB(si_electric_potential_unit);
+	DECL_CONV_STUB(si_energy_unit);
+	DECL_CONV_STUB(si_force_unit);
+	DECL_CONV_STUB(si_frequency_unit);
+	DECL_CONV_STUB(si_illuminance_unit);
+	DECL_CONV_STUB(si_inductance_unit);
+	DECL_CONV_STUB(si_magnetic_flux_density_unit);
+	DECL_CONV_STUB(si_magnetic_flux_unit);
+	DECL_CONV_STUB(si_power_unit);
+	DECL_CONV_STUB(si_pressure_unit);
+	DECL_CONV_STUB(si_radioactivity_unit);
+	DECL_CONV_STUB(si_resistance_unit);
+	DECL_CONV_STUB(si_unit);
+	DECL_CONV_STUB(simple_boolean_expression);
+	DECL_CONV_STUB(simple_numeric_expression);
+	DECL_CONV_STUB(slash_expression);
+	DECL_CONV_STUB(smeared_material_definition);
+	DECL_CONV_STUB(solid_angle_measure_with_unit);
+	DECL_CONV_STUB(solid_angle_unit);
+	DECL_CONV_STUB(solid_curve_font);
+	DECL_CONV_STUB(solid_replica);
+	DECL_CONV_STUB(solid_with_chamfered_edges);
+	DECL_CONV_STUB(solid_with_angle_based_chamfer);
+	DECL_CONV_STUB(solid_with_shape_element_pattern);
+	DECL_CONV_STUB(solid_with_circular_pattern);
+	DECL_CONV_STUB(solid_with_depression);
+	DECL_CONV_STUB(solid_with_pocket);
+	DECL_CONV_STUB(solid_with_circular_pocket);
+	DECL_CONV_STUB(solid_with_protrusion);
+	DECL_CONV_STUB(solid_with_circular_protrusion);
+	DECL_CONV_STUB(solid_with_hole);
+	DECL_CONV_STUB(solid_with_stepped_round_hole);
+	DECL_CONV_STUB(solid_with_conical_bottom_round_hole);
+	DECL_CONV_STUB(solid_with_constant_radius_edge_blend);
+	DECL_CONV_STUB(solid_with_slot);
+	DECL_CONV_STUB(solid_with_curved_slot);
+	DECL_CONV_STUB(solid_with_double_offset_chamfer);
+	DECL_CONV_STUB(solid_with_flat_bottom_round_hole);
+	DECL_CONV_STUB(solid_with_general_pocket);
+	DECL_CONV_STUB(solid_with_general_protrusion);
+	DECL_CONV_STUB(solid_with_groove);
+	DECL_CONV_STUB(solid_with_incomplete_circular_pattern);
+	DECL_CONV_STUB(solid_with_rectangular_pattern);
+	DECL_CONV_STUB(solid_with_incomplete_rectangular_pattern);
+	DECL_CONV_STUB(solid_with_rectangular_pocket);
+	DECL_CONV_STUB(solid_with_rectangular_protrusion);
+	DECL_CONV_STUB(solid_with_single_offset_chamfer);
+	DECL_CONV_STUB(solid_with_spherical_bottom_round_hole);
+	DECL_CONV_STUB(solid_with_stepped_round_hole_and_conical_transitions);
+	DECL_CONV_STUB(solid_with_straight_slot);
+	DECL_CONV_STUB(solid_with_tee_section_slot);
+	DECL_CONV_STUB(solid_with_through_depression);
+	DECL_CONV_STUB(solid_with_trapezoidal_section_slot);
+	DECL_CONV_STUB(solid_with_variable_radius_edge_blend);
+	DECL_CONV_STUB(source_for_requirement);
+	DECL_CONV_STUB(sourced_requirement);
+	DECL_CONV_STUB(specification_definition);
+	DECL_CONV_STUB(specified_higher_usage_occurrence);
+	DECL_CONV_STUB(sphere);
+	DECL_CONV_STUB(spherical_surface);
+	DECL_CONV_STUB(start_request);
+	DECL_CONV_STUB(start_work);
+	DECL_CONV_STUB(straightness_tolerance);
+	DECL_CONV_STUB(structured_dimension_callout);
+	DECL_CONV_STUB(structured_text_composition);
+	DECL_CONV_STUB(structured_text_representation);
+	DECL_CONV_STUB(subedge);
+	DECL_CONV_STUB(subface);
+	DECL_CONV_STUB(supplied_part_relationship);
+	DECL_CONV_STUB(surface_condition_callout);
+	DECL_CONV_STUB(swept_surface);
+	DECL_CONV_STUB(surface_of_linear_extrusion);
+	DECL_CONV_STUB(surface_of_revolution);
+	DECL_CONV_STUB(surface_patch);
+	DECL_CONV_STUB(surface_profile_tolerance);
+	DECL_CONV_STUB(surface_replica);
+	DECL_CONV_STUB(surface_side_style);
+	DECL_CONV_STUB(surface_style_boundary);
+	DECL_CONV_STUB(surface_style_control_grid);
+	DECL_CONV_STUB(surface_style_fill_area);
+	DECL_CONV_STUB(surface_style_parameter_line);
+	DECL_CONV_STUB(surface_style_reflectance_ambient);
+	DECL_CONV_STUB(surface_style_reflectance_ambient_diffuse);
+	DECL_CONV_STUB(surface_style_reflectance_ambient_diffuse_specular);
+	DECL_CONV_STUB(surface_style_rendering);
+	DECL_CONV_STUB(surface_style_rendering_with_properties);
+	DECL_CONV_STUB(surface_style_segmentation_curve);
+	DECL_CONV_STUB(surface_style_silhouette);
+	DECL_CONV_STUB(surface_style_usage);
+	DECL_CONV_STUB(surface_texture_representation);
+	DECL_CONV_STUB(surfaced_open_shell);
+	DECL_CONV_STUB(swept_disk_solid);
+	DECL_CONV_STUB(symbol);
+	DECL_CONV_STUB(symbol_representation_map);
+	DECL_CONV_STUB(symbol_style);
+	DECL_CONV_STUB(symbol_target);
+	DECL_CONV_STUB(symmetric_shape_aspect);
+	DECL_CONV_STUB(symmetry_tolerance);
+	DECL_CONV_STUB(table_representation_item);
+	DECL_CONV_STUB(tactile_appearance_representation);
+	DECL_CONV_STUB(tagged_text_format);
+	DECL_CONV_STUB(tagged_text_item);
+	DECL_CONV_STUB(tangent);
+	DECL_CONV_STUB(text_literal_with_associated_curves);
+	DECL_CONV_STUB(text_literal_with_blanking_box);
+	DECL_CONV_STUB(text_literal_with_extent);
+	DECL_CONV_STUB(text_string_representation);
+	DECL_CONV_STUB(text_style);
+	DECL_CONV_STUB(text_style_with_box_characteristics);
+	DECL_CONV_STUB(text_style_with_mirror);
+	DECL_CONV_STUB(text_style_with_spacing);
+	DECL_CONV_STUB(thermal_resistance_measure_with_unit);
+	DECL_CONV_STUB(thermal_resistance_unit);
+	DECL_CONV_STUB(thermodynamic_temperature_measure_with_unit);
+	DECL_CONV_STUB(thermodynamic_temperature_unit);
+	DECL_CONV_STUB(thickened_face_solid);
+	DECL_CONV_STUB(thickness_laminate_definition);
+	DECL_CONV_STUB(thickness_laminate_table);
+	DECL_CONV_STUB(time_interval);
+	DECL_CONV_STUB(time_interval_based_effectivity);
+	DECL_CONV_STUB(time_interval_with_bounds);
+	DECL_CONV_STUB(time_measure_with_unit);
+	DECL_CONV_STUB(time_unit);
+	DECL_CONV_STUB(tolerance_zone);
+	DECL_CONV_STUB(torus);
+	DECL_CONV_STUB(total_runout_tolerance);
+	DECL_CONV_STUB(track_blended_solid);
+	DECL_CONV_STUB(track_blended_solid_with_end_conditions);
+	DECL_CONV_STUB(trimmed_curve);
+	DECL_CONV_STUB(two_direction_repeat_factor);
+	DECL_CONV_STUB(unary_generic_expression);
+	DECL_CONV_STUB(unary_numeric_expression);
+	DECL_CONV_STUB(uncertainty_assigned_representation);
+	DECL_CONV_STUB(uncertainty_measure_with_unit);
+	DECL_CONV_STUB(uniform_curve);
+	DECL_CONV_STUB(uniform_resource_identifier);
+	DECL_CONV_STUB(uniform_surface);
+	DECL_CONV_STUB(usage_association);
+	DECL_CONV_STUB(user_defined_curve_font);
+	DECL_CONV_STUB(user_defined_marker);
+	DECL_CONV_STUB(user_defined_terminator_symbol);
+	DECL_CONV_STUB(user_selected_shape_elements);
+	DECL_CONV_STUB(value_range);
+	DECL_CONV_STUB(value_representation_item);
+	DECL_CONV_STUB(variable_semantics);
+	DECL_CONV_STUB(variational_representation_item);
+	DECL_CONV_STUB(vector);
+	DECL_CONV_STUB(vector_style);
+	DECL_CONV_STUB(velocity_measure_with_unit);
+	DECL_CONV_STUB(velocity_unit);
+	DECL_CONV_STUB(vertex);
+	DECL_CONV_STUB(vertex_loop);
+	DECL_CONV_STUB(vertex_point);
+	DECL_CONV_STUB(vertex_shell);
+	DECL_CONV_STUB(view_volume);
+	DECL_CONV_STUB(visual_appearance_representation);
+	DECL_CONV_STUB(volume_measure_with_unit);
+	DECL_CONV_STUB(volume_unit);
+	DECL_CONV_STUB(week_of_year_and_day_date);
+	DECL_CONV_STUB(wire_shell);
+	DECL_CONV_STUB(year_month);
+
+
+#undef DECL_CONV_STUB
+
+} //! STEP
+} //! Assimp
+
+#endif // INCLUDED_STEPFILE_READER_GEN_H

code/ImporterRegistry.cpp

@@ -197,6 +197,9 @@ corresponding preprocessor flag to selectively disable formats.
 #ifndef ASSIMP_BUILD_NO_MMD_IMPORTER
 #   include "MMDImporter.h"
 #endif
+#ifndef ASSIMP_BUILD_NO_STEPFILE_IMPORTER
+#   include "Importer/StepFile/StepFileImporter.h"
+#endif
 
 namespace Assimp {
 
@@ -352,6 +355,9 @@ void GetImporterInstanceList(std::vector< BaseImporter* >& out)
 #ifndef ASSIMP_BUILD_NO_MMD_IMPORTER
     out.push_back( new MMDImporter() );
 #endif
+#ifndef ASSIMP_BUILD_NO_STEPFILE_IMPORTER
+    out.push_back(new StepFile::StepFileImporter());
+#endif
 }
 
 /** will delete all registered importers. */

code/LWOAnimation.h

@@ -113,14 +113,14 @@ enum PrePostBehaviour
 // ---------------------------------------------------------------------------
 /** \brief Data structure for a LWO animation keyframe
  */
-struct Key
-{
-    Key()
-        : time(),
-        value(),
-        inter   (IT_LINE),
-        params()
-    {}
+struct Key {
+    Key() AI_NO_EXCEPT 
+    : time()
+    , value()
+    , inter(IT_LINE)
+    , params() {
+        // empty
+    }
 
     //! Current time
     double time;
@@ -144,17 +144,16 @@ struct Key
 // ---------------------------------------------------------------------------
 /** \brief Data structure for a LWO animation envelope
  */
-struct Envelope
-{
-    Envelope()
-        :   index()
-        ,   type    (EnvelopeType_Unknown)
-        ,   pre     (PrePostBehaviour_Constant)
-        ,   post    (PrePostBehaviour_Constant)
-
-        ,   old_first (0)
-        ,   old_last  (0)
-    {}
+struct Envelope {
+    Envelope() AI_NO_EXCEPT
+    : index()
+    , type(EnvelopeType_Unknown)
+    , pre(PrePostBehaviour_Constant)
+    , post(PrePostBehaviour_Constant)
+    , old_first(0)
+    , old_last(0) {
+        // empty
+    }
 
     //! Index of this envelope
     unsigned int index;
@@ -162,7 +161,7 @@ struct Envelope
     //! Type of envelope
     EnvelopeType type;
 
-    //! Pre and post-behaviour
+    //! Pre- and post-behavior
     PrePostBehaviour pre,post;
 
     //! Keyframes for this envelope

code/LWOFileData.h

@@ -261,14 +261,14 @@ namespace LWO {
  * \note We can't use the code in SmoothingGroups.inl here - the mesh
  *   structures of 3DS/ASE and LWO are too different.
  */
-struct Face : public aiFace
-{
+struct Face : public aiFace {
     //! Default construction
-    Face()
-        : surfaceIndex  (0)
-        , smoothGroup   (0)
-        , type          (AI_LWO_FACE)
-    {}
+    Face() AI_NO_EXCEPT
+    : surfaceIndex( 0 )
+    , smoothGroup( 0 )
+    , type( AI_LWO_FACE ) {
+        // empty
+    }
 
     //! Construction from given type
     explicit Face(uint32_t _type)

code/LimitBoneWeightsProcess.h

@@ -120,7 +120,7 @@ public:
     {
         unsigned int mBone; ///< Index of the bone
         float mWeight;      ///< Weight of that bone on this vertex
-        Weight()
+        Weight() AI_NO_EXCEPT
         : mBone(0)
         , mWeight(0.0f)
         { }

code/MD3FileData.h

@@ -246,7 +246,7 @@ struct Vertex
     uint16_t  NORMAL;
 } /*PACK_STRUCT*/;
 
-#include "./../include/assimp/Compiler/poppack1.h"
+#include <assimp/Compiler/poppack1.h>
 
 // -------------------------------------------------------------------------------
 /** @brief Unpack a Q3 16 bit vector to its full float3 representation

code/MD3Loader.h

@@ -125,7 +125,7 @@ enum AlphaTestFunc
  */
 struct ShaderMapBlock
 {
-    ShaderMapBlock()
+    ShaderMapBlock() AI_NO_EXCEPT
          :  blend_src   (BLEND_NONE)
          ,  blend_dest  (BLEND_NONE)
          ,  alpha_test  (AT_NONE)
@@ -150,7 +150,7 @@ struct ShaderMapBlock
  */
 struct ShaderDataBlock
 {
-    ShaderDataBlock()
+    ShaderDataBlock() AI_NO_EXCEPT
         :   cull    (CULL_CW)
     {}
 

code/MD4FileData.h

@@ -46,9 +46,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <vector>
 #include <sstream>
 
-#include "../include/assimp/types.h"
-#include "../include/assimp/mesh.h"
-#include "../include/assimp/anim.h"
+#include <assimp/types.h>
+#include <assimp/mesh.h>
+#include <assimp/anim.h>
 
 #if defined(_MSC_VER) ||  defined(__BORLANDC__) ||  defined (__BCPLUSPLUS__)
 #   pragma pack(push,1)

code/MD5Loader.cpp

@@ -420,6 +420,9 @@ void MD5Importer::LoadMD5MeshFile ()
         // generate unique vertices in our internal verbose format
         MakeDataUnique(meshSrc);
 
+        std::string name( meshSrc.mShader.C_Str() );
+        name += ".msh";
+        mesh->mName = name;
         mesh->mNumVertices = (unsigned int) meshSrc.mVertices.size();
         mesh->mVertices = new aiVector3D[mesh->mNumVertices];
         mesh->mTextureCoords[0] = new aiVector3D[mesh->mNumVertices];
@@ -471,7 +474,6 @@ void MD5Importer::LoadMD5MeshFile ()
                 MD5::ConvertQuaternion( boneSrc.mRotationQuat, boneSrc.mRotationQuatConverted );
             }
 
-            //unsigned int g = 0;
             pv = mesh->mVertices;
             for (MD5::VertexList::const_iterator iter =  meshSrc.mVertices.begin();iter != meshSrc.mVertices.end();++iter,++pv) {
                 // compute the final vertex position from all single weights
@@ -559,7 +561,9 @@ void MD5Importer::LoadMD5MeshFile ()
             // set this also as material name
             mat->AddProperty(&meshSrc.mShader,AI_MATKEY_NAME);
         }
-        else mat->AddProperty(&meshSrc.mShader,AI_MATKEY_TEXTURE_DIFFUSE(0));
+        else {
+            mat->AddProperty(&meshSrc.mShader, AI_MATKEY_TEXTURE_DIFFUSE(0));
+        }
         mesh->mMaterialIndex = n++;
     }
 #endif

code/MD5Parser.h

@@ -192,14 +192,14 @@ typedef std::vector< FrameDesc > FrameList;
 // ---------------------------------------------------------------------------
 /** Represents a vertex  descriptor in a MD5 file
 */
-struct VertexDesc
-{
-    VertexDesc()
-        : mFirstWeight  (0)
-        , mNumWeights   (0)
-    {}
+struct VertexDesc {
+    VertexDesc() AI_NO_EXCEPT
+    : mFirstWeight(0)
+    , mNumWeights(0) {
+        // empty
+    }
 
-    //! UV cordinate of the vertex
+    //! UV coordinate of the vertex
     aiVector2D mUV;
 
     //! Index of the first weight of the vertex in

code/MDCFileData.h

@@ -61,7 +61,6 @@ http://themdcfile.planetwolfenstein.gamespy.com/MDC_File_Format.pdf
 namespace Assimp {
 namespace MDC {
 
-
 // to make it easier for us, we test the magic word against both "endianesses"
 #define AI_MDC_MAGIC_NUMBER_BE  AI_MAKE_MAGIC("CPDI")
 #define AI_MDC_MAGIC_NUMBER_LE  AI_MAKE_MAGIC("IDPC")
@@ -79,8 +78,7 @@ namespace MDC {
 // ---------------------------------------------------------------------------
 /** \brief Data structure for a MDC file's main header
  */
-struct Header
-{
+struct Header {
     uint32_t ulIdent ;
     uint32_t ulVersion ;
     char ucName [ AI_MDC_MAXQPATH ] ;
@@ -100,8 +98,7 @@ struct Header
 // ---------------------------------------------------------------------------
 /** \brief Data structure for a MDC file's surface header
  */
-struct Surface
-{
+struct Surface {
     uint32_t ulIdent ;
     char ucName [ AI_MDC_MAXQPATH ] ;
     uint32_t ulFlags ;
@@ -118,23 +115,22 @@ struct Surface
     uint32_t ulOffsetFrameBaseFrames ;
     uint32_t ulOffsetFrameCompFrames ;
     uint32_t ulOffsetEnd;
-    Surface()
-        : ulIdent(),
-        ulFlags(),
-        ulNumCompFrames(),
-        ulNumBaseFrames(),
-        ulNumShaders(),
-        ulNumVertices(),
-        ulNumTriangles(),
-        ulOffsetTriangles(),
-        ulOffsetShaders(),
-        ulOffsetTexCoords(),
-        ulOffsetBaseVerts(),
-        ulOffsetCompVerts(),
-        ulOffsetFrameBaseFrames(),
-        ulOffsetFrameCompFrames(),
-        ulOffsetEnd()
-    {
+    Surface() AI_NO_EXCEPT
+    : ulIdent()
+    , ulFlags()
+    , ulNumCompFrames()
+    , ulNumBaseFrames()
+    , ulNumShaders() 
+    , ulNumVertices()
+    , ulNumTriangles()
+    , ulOffsetTriangles()
+    , ulOffsetShaders()
+    , ulOffsetTexCoords()
+    , ulOffsetBaseVerts() 
+    , ulOffsetCompVerts()
+    , ulOffsetFrameBaseFrames()
+    , ulOffsetFrameCompFrames()
+    , ulOffsetEnd() {
         ucName[AI_MDC_MAXQPATH-1] = '\0';
     }
 } PACK_STRUCT;
@@ -142,8 +138,7 @@ struct Surface
 // ---------------------------------------------------------------------------
 /** \brief Data structure for a MDC frame
  */
-struct Frame
-{
+struct Frame {
     //! bounding box minimum coords
     aiVector3D bboxMin ;
 
@@ -163,24 +158,21 @@ struct Frame
 // ---------------------------------------------------------------------------
 /** \brief Data structure for a MDC triangle
  */
-struct Triangle
-{
+struct Triangle {
     uint32_t aiIndices[3];
 } PACK_STRUCT;
 
 // ---------------------------------------------------------------------------
 /** \brief Data structure for a MDC texture coordinate
  */
-struct TexturCoord
-{
+struct TexturCoord {
     float u,v;
 } PACK_STRUCT;
 
 // ---------------------------------------------------------------------------
 /** \brief Data structure for a MDC base vertex
  */
-struct BaseVertex
-{
+struct BaseVertex {
     int16_t x,y,z;
     uint16_t normal;
 } PACK_STRUCT;
@@ -188,25 +180,20 @@ struct BaseVertex
 // ---------------------------------------------------------------------------
 /** \brief Data structure for a MDC compressed vertex
  */
-struct CompressedVertex
-{
+struct CompressedVertex {
     uint8_t xd,yd,zd,nd;
 } PACK_STRUCT;
 
-
 // ---------------------------------------------------------------------------
 /** \brief Data structure for a MDC shader
  */
-struct Shader
-{
+struct Shader {
     char ucName [ AI_MDC_MAXQPATH ] ;
     uint32_t ulPath;
-
 } PACK_STRUCT;
 
 #include <assimp/Compiler/poppack1.h>
 
-
 // ---------------------------------------------------------------------------
 /** Build a floating point vertex from the compressed data in MDC files
  */
@@ -215,6 +202,7 @@ void BuildVertex(const Frame& frame,
     const CompressedVertex& cvert,
     aiVector3D& vXYZOut,
     aiVector3D& vNorOut);
-}}
+}
+}
 
 #endif // !! AI_MDCFILEHELPER_H_INC

code/MDCLoader.cpp

@@ -434,10 +434,12 @@ void MDCImporter::InternReadFile(
     else if (1 == pScene->mNumMeshes)
     {
         pScene->mRootNode = new aiNode();
-        pScene->mRootNode->mName = pScene->mMeshes[0]->mName;
-        pScene->mRootNode->mNumMeshes = 1;
-        pScene->mRootNode->mMeshes = new unsigned int[1];
-        pScene->mRootNode->mMeshes[0] = 0;
+        if ( nullptr != pScene->mMeshes[0] ) {
+            pScene->mRootNode->mName = pScene->mMeshes[0]->mName;
+            pScene->mRootNode->mNumMeshes = 1;
+            pScene->mRootNode->mMeshes = new unsigned int[1];
+            pScene->mRootNode->mMeshes[0] = 0;
+        }
     }
     else
     {

code/MDLFileData.h

@@ -709,7 +709,7 @@ struct GroupFrame
     SimpleFrame *frames;
 } PACK_STRUCT;
 
-#include "./../include/assimp/Compiler/poppack1.h"
+#include <assimp/Compiler/poppack1.h>
 
 // -------------------------------------------------------------------------------------
 /** \struct IntFace_MDL7
@@ -717,11 +717,9 @@ struct GroupFrame
  */
 struct IntFace_MDL7 {
     // provide a constructor for our own convenience
-    IntFace_MDL7()
-    {
-        // set everything to zero
-        mIndices[0] = mIndices[1] = mIndices[2] = 0;
-        iMatIndex[0] = iMatIndex[1] = 0;
+    IntFace_MDL7() AI_NO_EXCEPT {
+        ::memset( mIndices, 0, sizeof(uint32_t) *3);
+        ::memset( iMatIndex, 0, sizeof( unsigned int) *2);
     }
 
     //! Vertex indices
@@ -737,13 +735,11 @@ struct IntFace_MDL7 {
  *  which has been created from two single materials along with the
  *  original material indices.
  */
-struct IntMaterial_MDL7
-{
+struct IntMaterial_MDL7 {
     // provide a constructor for our own convenience
-    IntMaterial_MDL7()
-    {
-        pcMat = NULL;
-        iOldMatIndices[0] = iOldMatIndices[1] = 0;
+    IntMaterial_MDL7() AI_NO_EXCEPT
+    : pcMat( nullptr ) {
+        ::memset( iOldMatIndices, 0, sizeof(unsigned int) *2);
     }
 
     //! Material instance
@@ -761,7 +757,7 @@ struct IntMaterial_MDL7
 struct IntBone_MDL7 : aiBone
 {
     //! Default constructor
-    IntBone_MDL7() : iParent (0xffff)
+    IntBone_MDL7() AI_NO_EXCEPT : iParent (0xffff)
     {
         pkeyPositions.reserve(30);
         pkeyScalings.reserve(30);
@@ -806,12 +802,12 @@ struct IntFrameInfo_MDL7
 struct IntGroupInfo_MDL7
 {
     //! Default constructor
-    IntGroupInfo_MDL7()
+    IntGroupInfo_MDL7() AI_NO_EXCEPT
         :   iIndex(0)
-        ,   pcGroup(NULL)
-        ,   pcGroupUVs(NULL)
-        ,   pcGroupTris(NULL)
-        ,   pcGroupVerts(NULL)
+        ,   pcGroup(nullptr)
+        ,   pcGroupUVs(nullptr)
+        ,   pcGroupTris(nullptr)
+        ,   pcGroupVerts(nullptr)
         {}
 
     //! Construction from an existing group header
@@ -843,7 +839,7 @@ struct IntGroupInfo_MDL7
 //! Holds the data that belongs to a MDL7 mesh group
 struct IntGroupData_MDL7
 {
-    IntGroupData_MDL7()
+    IntGroupData_MDL7() AI_NO_EXCEPT
         : bNeed2UV(false)
     {}
 
@@ -872,10 +868,9 @@ struct IntGroupData_MDL7
 
 // -------------------------------------------------------------------------------------
 //! Holds data from an MDL7 file that is shared by all mesh groups
-struct IntSharedData_MDL7
-{
+struct IntSharedData_MDL7 {
     //! Default constructor
-    IntSharedData_MDL7()
+    IntSharedData_MDL7() AI_NO_EXCEPT
         : apcOutBones(),
         iNum()
     {

code/MDLLoader.cpp

@@ -413,8 +413,9 @@ void MDLImporter::InternReadFile_Quake1() {
 
 #if 1
         // FIXME: the cast is wrong and cause a warning on clang 5.0
-        // disable thi code for now, fix it later
+        // disable this code for now, fix it later
         ai_assert(false && "Bad pointer cast");
+        pcFirstFrame = nullptr; // Workaround: msvc++ C4703 error
 #else
         BE_NCONST MDL::GroupFrame* pcFrames2 = (BE_NCONST MDL::GroupFrame*)pcFrames;
         pcFirstFrame = (BE_NCONST MDL::SimpleFrame*)(&pcFrames2->time + pcFrames->type);

code/MMDImporter.cpp

@@ -72,18 +72,16 @@ using namespace std;
 // ------------------------------------------------------------------------------------------------
 //  Default constructor
 MMDImporter::MMDImporter()
-    : m_Buffer(),
-      // m_pRootObject( NULL ),
-      m_strAbsPath("") {
-  DefaultIOSystem io;
-  m_strAbsPath = io.getOsSeparator();
+: m_Buffer()
+, m_strAbsPath("") {
+    DefaultIOSystem io;
+    m_strAbsPath = io.getOsSeparator();
 }
 
 // ------------------------------------------------------------------------------------------------
 //  Destructor.
 MMDImporter::~MMDImporter() {
-  // delete m_pRootObject;
-  // m_pRootObject = NULL;
+    // empty
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -96,8 +94,7 @@ bool MMDImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler,
   } else // Check file Header
   {
     static const char *pTokens[] = {"PMX "};
-    return BaseImporter::SearchFileHeaderForToken(pIOHandler, pFile, pTokens,
-                                                  1);
+    return BaseImporter::SearchFileHeaderForToken(pIOHandler, pFile, pTokens, 1);
   }
 }
 
@@ -354,8 +351,11 @@ aiMaterial *MMDImporter::CreateMaterial(const pmx::PmxMaterial *pMat,
   float shininess = pMat->specularlity;
   mat->AddProperty(&shininess, 1, AI_MATKEY_SHININESS_STRENGTH);
 
-  aiString texture_path(pModel->textures[pMat->diffuse_texture_index]);
-  mat->AddProperty(&texture_path, AI_MATKEY_TEXTURE(aiTextureType_DIFFUSE, 0));
+  if(pMat->diffuse_texture_index >= 0) {
+      aiString texture_path(pModel->textures[pMat->diffuse_texture_index]);
+      mat->AddProperty(&texture_path, AI_MATKEY_TEXTURE(aiTextureType_DIFFUSE, 0));
+  }
+
   int mapping_uvwsrc = 0;
   mat->AddProperty(&mapping_uvwsrc, 1,
                    AI_MATKEY_UVWSRC(aiTextureType_DIFFUSE, 0));

code/MMDPmxParser.cpp

@@ -94,16 +94,15 @@ namespace pmx
 		if (encoding == 0)
 		{
 			// UTF16 to UTF8
-			std::string result;
-
-			const char* sourceStart = buffer.data();
+			const uint16_t* sourceStart = (uint16_t*)buffer.data();
 			const unsigned int targetSize = size * 3; // enough to encode
-			char* targetStart = new char[targetSize]();
-			const char* targetReserved = targetStart;
-            utf8::utf16to8( sourceStart, sourceStart + size, targetStart );
+			char *targetStart = new char[targetSize];
+            std::memset(targetStart, 0, targetSize * sizeof(char));
+            
+            utf8::utf16to8( sourceStart, sourceStart + size/2, targetStart );
 
-			result.assign(targetReserved, targetStart - targetReserved);
-			delete[] targetReserved;
+			std::string result(targetStart);
+            delete [] targetStart;
 			return result;
 		}
 		else
@@ -475,7 +474,6 @@ namespace pmx
 
     void PmxSoftBody::Read(std::istream * /*stream*/, PmxSetting * /*setting*/)
 	{
-		// 未実装
 		std::cerr << "Not Implemented Exception" << std::endl;
         throw DeadlyImportError("MMD: Not Implemented Exception");
     }
@@ -511,31 +509,27 @@ namespace pmx
 
 	void PmxModel::Read(std::istream *stream)
 	{
-		// マジック
 		char magic[4];
 		stream->read((char*) magic, sizeof(char) * 4);
 		if (magic[0] != 0x50 || magic[1] != 0x4d || magic[2] != 0x58 || magic[3] != 0x20)
 		{
 			std::cerr << "invalid magic number." << std::endl;
-            throw DeadlyImportError("MMD: invalid magic number.");
-        }
-		// バージョン
+      throw DeadlyImportError("MMD: invalid magic number.");
+    }
 		stream->read((char*) &version, sizeof(float));
 		if (version != 2.0f && version != 2.1f)
 		{
 			std::cerr << "this is not ver2.0 or ver2.1 but " << version << "." << std::endl;
             throw DeadlyImportError("MMD: this is not ver2.0 or ver2.1 but " + to_string(version));
-        }
-		// ファイル設定
+    }
 		this->setting.Read(stream);
 
-		// モデル情報
 		this->model_name = ReadString(stream, setting.encoding);
 		this->model_english_name = ReadString(stream, setting.encoding);
 		this->model_comment = ReadString(stream, setting.encoding);
 		this->model_english_comment = ReadString(stream, setting.encoding);
 
-		// 頂点
+		// read vertices
 		stream->read((char*) &vertex_count, sizeof(int));
 		this->vertices = mmd::make_unique<PmxVertex []>(vertex_count);
 		for (int i = 0; i < vertex_count; i++)
@@ -543,7 +537,7 @@ namespace pmx
 			vertices[i].Read(stream, &setting);
 		}
 
-		// 面
+		// read indices
 		stream->read((char*) &index_count, sizeof(int));
 		this->indices = mmd::make_unique<int []>(index_count);
 		for (int i = 0; i < index_count; i++)
@@ -551,7 +545,7 @@ namespace pmx
 			this->indices[i] = ReadIndex(stream, setting.vertex_index_size);
 		}
 
-		// テクスチャ
+		// read texture names
 		stream->read((char*) &texture_count, sizeof(int));
 		this->textures = mmd::make_unique<std::string []>(texture_count);
 		for (int i = 0; i < texture_count; i++)
@@ -559,7 +553,7 @@ namespace pmx
 			this->textures[i] = ReadString(stream, setting.encoding);
 		}
 
-		// マテリアル
+		// read materials
 		stream->read((char*) &material_count, sizeof(int));
 		this->materials = mmd::make_unique<PmxMaterial []>(material_count);
 		for (int i = 0; i < material_count; i++)
@@ -567,7 +561,7 @@ namespace pmx
 			this->materials[i].Read(stream, &setting);
 		}
 
-		// ボーン
+		// read bones
 		stream->read((char*) &this->bone_count, sizeof(int));
 		this->bones = mmd::make_unique<PmxBone []>(this->bone_count);
 		for (int i = 0; i < this->bone_count; i++)
@@ -575,7 +569,7 @@ namespace pmx
 			this->bones[i].Read(stream, &setting);
 		}
 
-		// モーフ
+		// read morphs
 		stream->read((char*) &this->morph_count, sizeof(int));
 		this->morphs = mmd::make_unique<PmxMorph []>(this->morph_count);
 		for (int i = 0; i < this->morph_count; i++)
@@ -583,7 +577,7 @@ namespace pmx
 			this->morphs[i].Read(stream, &setting);
 		}
 
-		// 表示枠
+		// read display frames
 		stream->read((char*) &this->frame_count, sizeof(int));
 		this->frames = mmd::make_unique<PmxFrame []>(this->frame_count);
 		for (int i = 0; i < this->frame_count; i++)
@@ -591,7 +585,7 @@ namespace pmx
 			this->frames[i].Read(stream, &setting);
 		}
 
-		// 剛体
+		// read rigid bodies
 		stream->read((char*) &this->rigid_body_count, sizeof(int));
 		this->rigid_bodies = mmd::make_unique<PmxRigidBody []>(this->rigid_body_count);
 		for (int i = 0; i < this->rigid_body_count; i++)
@@ -599,7 +593,7 @@ namespace pmx
 			this->rigid_bodies[i].Read(stream, &setting);
 		}
 
-		// ジョイント
+		// read joints
 		stream->read((char*) &this->joint_count, sizeof(int));
 		this->joints = mmd::make_unique<PmxJoint []>(this->joint_count);
 		for (int i = 0; i < this->joint_count; i++)

code/MS3DLoader.cpp

@@ -181,8 +181,7 @@ void MS3DImporter :: CollectChildJoints(const std::vector<TempJoint>& joints,
             ch->mParent = nd;
 
             ch->mTransformation = aiMatrix4x4::Translation(joints[i].position,aiMatrix4x4()=aiMatrix4x4())*
-                // XXX actually, I don't *know* why we need the inverse here. Probably column vs. row order?
-                aiMatrix4x4().FromEulerAnglesXYZ(joints[i].rotation).Transpose();
+                aiMatrix4x4().FromEulerAnglesXYZ(joints[i].rotation);
 
             const aiMatrix4x4 abs = absTrafo*ch->mTransformation;
             for(unsigned int a = 0; a < mScene->mNumMeshes; ++a) {
@@ -639,11 +638,8 @@ void MS3DImporter::InternReadFile( const std::string& pFile,
                     aiQuatKey& q = nd->mRotationKeys[nd->mNumRotationKeys++];
 
                     q.mTime = (*rot).time*animfps;
-
-                    // XXX it seems our matrix&quaternion code has faults in its conversion routines --
-                    // aiQuaternion(x,y,z) seems to besomething different as quat(matrix.fromeuler(x,y,z)).
-                    q.mValue = aiQuaternion(aiMatrix3x3(aiMatrix4x4().FromEulerAnglesXYZ((*rot).value)*
-                        aiMatrix4x4().FromEulerAnglesXYZ((*it).rotation)).Transpose());
+                    q.mValue = aiQuaternion(aiMatrix3x3(aiMatrix4x4().FromEulerAnglesXYZ((*it).rotation)*
+                        aiMatrix4x4().FromEulerAnglesXYZ((*rot).value)));
                 }
             }
 

code/MaterialSystem.cpp

@@ -194,12 +194,18 @@ aiReturn aiGetMaterialIntegerArray(const aiMaterial* pMat,
     // data is given in ints, simply copy it
     unsigned int iWrite = 0;
     if( aiPTI_Integer == prop->mType || aiPTI_Buffer == prop->mType)    {
-        iWrite = prop->mDataLength / sizeof(int32_t);
+        iWrite = std::max(static_cast<unsigned int>(prop->mDataLength / sizeof(int32_t)), 1u);
         if (pMax) {
-            iWrite = std::min(*pMax,iWrite); ;
+            iWrite = std::min(*pMax,iWrite);
         }
-        for (unsigned int a = 0; a < iWrite;++a) {
-            pOut[a] = static_cast<int>(reinterpret_cast<int32_t*>(prop->mData)[a]);
+        if (1 == prop->mDataLength) {
+            // bool type, 1 byte
+            *pOut = static_cast<int>(*prop->mData);
+        }
+        else {
+            for (unsigned int a = 0; a < iWrite;++a) {
+                pOut[a] = static_cast<int>(reinterpret_cast<int32_t*>(prop->mData)[a]);
+            }
         }
         if (pMax) {
             *pMax = iWrite;
@@ -387,26 +393,6 @@ aiReturn aiGetMaterialTexture(const C_STRUCT aiMaterial* mat,
     return AI_SUCCESS;
 }
 
-static aiMaterial *DefaultMaterial = nullptr;
-
-// ------------------------------------------------------------------------------------------------
-// Will return the default material.
-aiMaterial *aiCreateAndRegisterDefaultMaterial() {
-    if (nullptr == DefaultMaterial) {
-        DefaultMaterial = new aiMaterial;
-        aiString s;
-        s.Set(AI_DEFAULT_MATERIAL_NAME);
-        DefaultMaterial->AddProperty(&s, AI_MATKEY_NAME);
-    }
-
-    return DefaultMaterial;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Will return the default material.
-void aiReleaseDefaultMaterial() {
-    DefaultMaterial = nullptr;
-}
 
 static const unsigned int DefaultNumAllocated = 5;
 

code/OFFLoader.cpp

@@ -106,15 +106,23 @@ const aiImporterDesc* OFFImporter::GetInfo () const
     return &desc;
 }
 
+
+// skip blank space, lines and comments
+static void NextToken(const char **car, const char* end) {
+  SkipSpacesAndLineEnd(car);
+  while (*car < end && (**car == '#' || **car == '\n' || **car == '\r')) {
+    SkipLine(car);
+    SkipSpacesAndLineEnd(car);
+  }
+}
+
 // ------------------------------------------------------------------------------------------------
 // Imports the given file into the given scene structure.
-void OFFImporter::InternReadFile( const std::string& pFile,
-    aiScene* pScene, IOSystem* pIOHandler)
-{
+void OFFImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler) {
     std::unique_ptr<IOStream> file( pIOHandler->Open( pFile, "rb"));
 
     // Check whether we can read from the file
-    if( file.get() == NULL) {
+    if( file.get() == nullptr) {
         throw DeadlyImportError( "Failed to open OFF file " + pFile + ".");
     }
 
@@ -123,15 +131,61 @@ void OFFImporter::InternReadFile( const std::string& pFile,
     TextFileToBuffer(file.get(),mBuffer2);
     const char* buffer = &mBuffer2[0];
 
-    char line[4096];
-    GetNextLine(buffer,line);
-    if ('O' == line[0]) {
-        GetNextLine(buffer,line); // skip the 'OFF' line
+    // Proper OFF header parser. We only implement normal loading for now.
+    bool hasTexCoord = false, hasNormals = false, hasColors = false;
+    bool hasHomogenous = false, hasDimension = false;
+    unsigned int dimensions = 3;
+    const char* car = buffer;
+    const char* end = buffer + mBuffer2.size();
+    NextToken(&car, end);
+    
+    if (car < end - 2 && car[0] == 'S' && car[1] == 'T') {
+      hasTexCoord = true; car += 2;
+    }
+    if (car < end - 1 && car[0] == 'C') {
+      hasColors = true; car++;
+    }
+    if (car < end- 1 && car[0] == 'N') {
+      hasNormals = true; car++;
+    }
+    if (car < end - 1 && car[0] == '4') {
+      hasHomogenous = true; car++;
+    }
+    if (car < end - 1 && car[0] == 'n') {
+      hasDimension = true; car++;
+    }
+    if (car < end - 3 && car[0] == 'O' && car[1] == 'F' && car[2] == 'F') {
+        car += 3;
+	NextToken(&car, end);
+    } else {
+      // in case there is no OFF header (which is allowed by the
+      // specification...), then we might have unintentionally read an
+      // additional dimension from the primitive count fields
+      dimensions = 3;
+      hasHomogenous = false;
+      NextToken(&car, end);
+      
+      // at this point the next token should be an integer number
+      if (car >= end - 1 || *car < '0' || *car > '9') {
+	throw DeadlyImportError("OFF: Header is invalid");
+      }
+    }
+    if (hasDimension) {
+        dimensions = strtoul10(car, &car);
+	NextToken(&car, end);
+    }
+    if (dimensions > 3) {
+        throw DeadlyImportError
+	  ("OFF: Number of vertex coordinates higher than 3 unsupported");
     }
 
-    const char* sz = line; SkipSpaces(&sz);
-    const unsigned int numVertices = strtoul10(sz,&sz);SkipSpaces(&sz);
-    const unsigned int numFaces = strtoul10(sz,&sz);
+    NextToken(&car, end);
+    const unsigned int numVertices = strtoul10(car, &car);
+    NextToken(&car, end);
+    const unsigned int numFaces = strtoul10(car, &car);
+    NextToken(&car, end);
+    strtoul10(car, &car);  // skip edge count
+    NextToken(&car, end);
 
     if (!numVertices) {
         throw DeadlyImportError("OFF: There are no valid vertices");
@@ -147,91 +201,127 @@ void OFFImporter::InternReadFile( const std::string& pFile,
     pScene->mMeshes[0] = mesh;
 
     mesh->mNumFaces = numFaces;
-    aiFace* faces = new aiFace [mesh->mNumFaces];
+    aiFace* faces = new aiFace[mesh->mNumFaces];
     mesh->mFaces = faces;
 
-    std::vector<aiVector3D> tempPositions(numVertices);
+    mesh->mNumVertices = numVertices;
+    mesh->mVertices = new aiVector3D[numVertices];
+    mesh->mNormals = hasNormals ? new aiVector3D[numVertices] : nullptr;
+    mesh->mColors[0] = hasColors ? new aiColor4D[numVertices] : nullptr;
+
+    if (hasTexCoord) {
+        mesh->mNumUVComponents[0] = 2;
+        mesh->mTextureCoords[0] = new aiVector3D[numVertices];
+    }
+    char line[4096];
+    buffer = car;
+    const char *sz = car;
 
     // now read all vertex lines
-    for (unsigned int i = 0; i< numVertices;++i)
-    {
-        if(!GetNextLine(buffer,line))
-        {
+    for (unsigned int i = 0; i < numVertices; ++i) {
+        if(!GetNextLine(buffer, line)) {
             ASSIMP_LOG_ERROR("OFF: The number of verts in the header is incorrect");
             break;
         }
-        aiVector3D& v = tempPositions[i];
-
-        sz = line; SkipSpaces(&sz);
-        sz = fast_atoreal_move<ai_real>(sz,(ai_real&)v.x); SkipSpaces(&sz);
-        sz = fast_atoreal_move<ai_real>(sz,(ai_real&)v.y); SkipSpaces(&sz);
-        fast_atoreal_move<ai_real>(sz,(ai_real&)v.z);
+        aiVector3D& v = mesh->mVertices[i];	
+        sz = line;
+
+	// helper array to write a for loop over possible dimension values
+	ai_real* vec[3] = {&v.x, &v.y, &v.z};
+
+	// stop at dimensions: this allows loading 1D or 2D coordinate vertices
+        for (unsigned int dim = 0; dim < dimensions; ++dim ) {
+	    SkipSpaces(&sz);
+	    sz = fast_atoreal_move<ai_real>(sz, *vec[dim]);
+	}
+
+	// if has homogenous coordinate, divide others by this one
+	if (hasHomogenous) {
+	    SkipSpaces(&sz);
+	    ai_real w = 1.;
+	    sz = fast_atoreal_move<ai_real>(sz, w);
+            for (unsigned int dim = 0; dim < dimensions; ++dim ) {
+	        *(vec[dim]) /= w;
+	    }
+	}
+
+	// read optional normals
+	if (hasNormals) {
+	    aiVector3D& n = mesh->mNormals[i];
+	    SkipSpaces(&sz);
+	    sz = fast_atoreal_move<ai_real>(sz,(ai_real&)n.x);
+	    SkipSpaces(&sz);
+	    sz = fast_atoreal_move<ai_real>(sz,(ai_real&)n.y);
+	    SkipSpaces(&sz);
+	    fast_atoreal_move<ai_real>(sz,(ai_real&)n.z);
+	}
+	
+	// reading colors is a pain because the specification says it can be
+	// integers or floats, and any number of them between 1 and 4 included,
+	// until the next comment or end of line
+	// in theory should be testing type !
+	if (hasColors) {
+	    aiColor4D& c = mesh->mColors[0][i];
+	    SkipSpaces(&sz);
+	    sz = fast_atoreal_move<ai_real>(sz,(ai_real&)c.r);
+            if (*sz != '#' && *sz != '\n' && *sz != '\r') {
+	        SkipSpaces(&sz);
+	        sz = fast_atoreal_move<ai_real>(sz,(ai_real&)c.g);
+            } else {
+	        c.g = 0.;
+	    }
+            if (*sz != '#' && *sz != '\n' && *sz != '\r') {
+	        SkipSpaces(&sz);
+	        sz = fast_atoreal_move<ai_real>(sz,(ai_real&)c.b);
+            } else {
+	        c.b = 0.;
+	    }
+            if (*sz != '#' && *sz != '\n' && *sz != '\r') {
+	        SkipSpaces(&sz);
+	        sz = fast_atoreal_move<ai_real>(sz,(ai_real&)c.a);
+            } else {
+	        c.a = 1.;
+	    }
+	}
+        if (hasTexCoord) {
+	    aiVector3D& t = mesh->mTextureCoords[0][i];
+	    SkipSpaces(&sz);
+	    sz = fast_atoreal_move<ai_real>(sz,(ai_real&)t.x);
+	    SkipSpaces(&sz);
+	    fast_atoreal_move<ai_real>(sz,(ai_real&)t.y);
+	}
     }
 
-
-    // First find out how many vertices we'll need
-    const char* old = buffer;
-    for (unsigned int i = 0; i< mesh->mNumFaces;++i)
-    {
-        if(!GetNextLine(buffer,line))
-        {
+    // load faces with their indices
+    faces = mesh->mFaces;
+    for (unsigned int i = 0; i < numFaces; ) {
+        if(!GetNextLine(buffer,line)) {
             ASSIMP_LOG_ERROR("OFF: The number of faces in the header is incorrect");
             break;
         }
-        sz = line;SkipSpaces(&sz);
-        faces->mNumIndices = strtoul10(sz,&sz);
-        if(!(faces->mNumIndices) || faces->mNumIndices > 9)
-        {
-            ASSIMP_LOG_ERROR("OFF: Faces with zero indices aren't allowed");
-            --mesh->mNumFaces;
-            continue;
-        }
-        mesh->mNumVertices += faces->mNumIndices;
-        ++faces;
-    }
-
-    if (!mesh->mNumVertices)
-        throw DeadlyImportError("OFF: There are no valid faces");
-
-    // allocate storage for the output vertices
-    std::vector<aiVector3D> verts;
-    verts.reserve(mesh->mNumVertices);
-
-    // second: now parse all face indices
-    buffer = old;
-    faces = mesh->mFaces;
-    for (unsigned int i = 0, p = 0; i< mesh->mNumFaces;)
-    {
-        if(!GetNextLine(buffer,line))break;
-
         unsigned int idx;
-        sz = line;SkipSpaces(&sz);
+        sz = line; SkipSpaces(&sz);
         idx = strtoul10(sz,&sz);
-        if(!(idx) || idx > 9)
+        if(!idx || idx > 9) {
+	    ASSIMP_LOG_ERROR("OFF: Faces with zero indices aren't allowed");
+            --mesh->mNumFaces;
             continue;
-
-        faces->mIndices = new unsigned int [faces->mNumIndices];
-        for (unsigned int m = 0; m < faces->mNumIndices;++m)
-        {
+	}
+	faces->mNumIndices = idx;
+        faces->mIndices = new unsigned int[faces->mNumIndices];
+        for (unsigned int m = 0; m < faces->mNumIndices;++m) {
             SkipSpaces(&sz);
             idx = strtoul10(sz,&sz);
-            if ((idx) >= numVertices)
-            {
+            if (idx >= numVertices) {
                 ASSIMP_LOG_ERROR("OFF: Vertex index is out of range");
-                idx = numVertices-1;
+                idx = numVertices - 1;
             }
-            faces->mIndices[m] = p++;
-            verts.push_back(tempPositions[idx]);
+            faces->mIndices[m] = idx;
         }
         ++i;
         ++faces;
     }
-
-    if (mesh->mNumVertices != verts.size()) {
-        throw DeadlyImportError("OFF: Vertex count mismatch");
-    }
-    mesh->mVertices = new aiVector3D[verts.size()];
-    memcpy(mesh->mVertices, &verts[0], verts.size() * sizeof(aiVector3D));
+    
     // generate the output node graph
     pScene->mRootNode = new aiNode();
     pScene->mRootNode->mName.Set("<OFFRoot>");
@@ -248,8 +338,8 @@ void OFFImporter::InternReadFile( const std::string& pFile,
     pcMat->AddProperty(&clr,1,AI_MATKEY_COLOR_DIFFUSE);
     pScene->mMaterials[0] = pcMat;
 
-    const int twosided =1;
-    pcMat->AddProperty(&twosided,1,AI_MATKEY_TWOSIDED);
+    const int twosided = 1;
+    pcMat->AddProperty(&twosided, 1, AI_MATKEY_TWOSIDED);
 }
 
 #endif // !! ASSIMP_BUILD_NO_OFF_IMPORTER

code/ObjFileImporter.cpp

@@ -105,7 +105,7 @@ bool ObjFileImporter::CanRead( const std::string& pFile, IOSystem*  pIOHandler ,
 }
 
 // ------------------------------------------------------------------------------------------------
-const aiImporterDesc* ObjFileImporter::GetInfo () const {
+const aiImporterDesc* ObjFileImporter::GetInfo() const {
     return &desc;
 }
 
@@ -211,12 +211,29 @@ void ObjFileImporter::CreateDataFromImport(const ObjFile::Model* pModel, aiScene
     }
 
     if (pModel->m_Objects.size() > 0) {
+
+        unsigned int meshCount = 0;
+        unsigned int childCount = 0;
+
+        for(size_t index = 0; index < pModel->m_Objects.size(); ++index) {
+            if(pModel->m_Objects[index]) {
+                ++childCount;
+                meshCount += (unsigned int)pModel->m_Objects[index]->m_Meshes.size();
+            }
+        }
+
+        // Allocate space for the child nodes on the root node
+        pScene->mRootNode->mChildren = new aiNode*[ childCount ];
+
         // Create nodes for the whole scene
         std::vector<aiMesh*> MeshArray;
+        MeshArray.reserve(meshCount);
         for (size_t index = 0; index < pModel->m_Objects.size(); ++index) {
             createNodes(pModel, pModel->m_Objects[index], pScene->mRootNode, pScene, MeshArray);
         }
 
+        ai_assert(pScene->mRootNode->mNumChildren == childCount);
+
         // Create mesh pointer buffer for this scene
         if (pScene->mNumMeshes > 0) {
             pScene->mMeshes = new aiMesh*[MeshArray.size()];
@@ -234,7 +251,7 @@ void ObjFileImporter::CreateDataFromImport(const ObjFile::Model* pModel, aiScene
 
 		std::unique_ptr<aiMesh> mesh( new aiMesh );
         mesh->mPrimitiveTypes = aiPrimitiveType_POINT;
-        unsigned int n = pModel->m_Vertices.size();
+        unsigned int n = (unsigned int)pModel->m_Vertices.size();
         mesh->mNumVertices = n;
 
         mesh->mVertices = new aiVector3D[n];
@@ -287,9 +304,8 @@ aiNode *ObjFileImporter::createNodes(const ObjFile::Model* pModel, const ObjFile
     pNode->mName = pObject->m_strObjName;
 
     // If we have a parent node, store it
-    if( pParent != NULL ) {
-        appendChildToParentNode( pParent, pNode );
-    }
+    ai_assert( NULL != pParent );
+    appendChildToParentNode( pParent, pNode );
 
     for ( size_t i=0; i< pObject->m_Meshes.size(); ++i ) {
         unsigned int meshId = pObject->m_Meshes[ i ];
@@ -442,8 +458,8 @@ void ObjFileImporter::createVertexArray(const ObjFile::Model* pModel,
     pMesh->mNumVertices = numIndices;
     if (pMesh->mNumVertices == 0) {
         throw DeadlyImportError( "OBJ: no vertices" );
-    } else if (pMesh->mNumVertices > AI_MAX_ALLOC(aiVector3D)) {
-        throw DeadlyImportError( "OBJ: Too many vertices, would run out of memory" );
+    } else if (pMesh->mNumVertices > AI_MAX_VERTICES) {
+        throw DeadlyImportError( "OBJ: Too many vertices" );
     }
     pMesh->mVertices = new aiVector3D[ pMesh->mNumVertices ];
 
@@ -770,25 +786,8 @@ void ObjFileImporter::appendChildToParentNode(aiNode *pParent, aiNode *pChild)
     // Assign parent to child
     pChild->mParent = pParent;
 
-    // If already children was assigned to the parent node, store them in a
-    std::vector<aiNode*> temp;
-    if (pParent->mChildren != NULL)
-    {
-        ai_assert( 0 != pParent->mNumChildren );
-        for (size_t index = 0; index < pParent->mNumChildren; index++)
-        {
-            temp.push_back(pParent->mChildren [ index ] );
-        }
-        delete [] pParent->mChildren;
-    }
-
     // Copy node instances into parent node
     pParent->mNumChildren++;
-    pParent->mChildren = new aiNode*[ pParent->mNumChildren ];
-    for (size_t index = 0; index < pParent->mNumChildren-1; index++)
-    {
-        pParent->mChildren[ index ] = temp [ index ];
-    }
     pParent->mChildren[ pParent->mNumChildren-1 ] = pChild;
 }
 

code/OptimizeMeshes.h

@@ -67,20 +67,22 @@ namespace Assimp    {
 class OptimizeMeshesProcess : public BaseProcess
 {
 public:
-
+    /// @brief  The class constructor.
     OptimizeMeshesProcess();
+
+    /// @brief  The class destcructor,
     ~OptimizeMeshesProcess();
 
 
     /** @brief Internal utility to store additional mesh info
      */
-    struct MeshInfo
-    {
-        MeshInfo()
-            :   instance_cnt  (0)
-            ,   vertex_format (0)
-            ,   output_id     (0xffffffff)
-        {}
+    struct MeshInfo {
+        MeshInfo() AI_NO_EXCEPT
+        : instance_cnt(0)
+        , vertex_format(0)
+        , output_id(0xffffffff) {
+            // empty
+        }
 
         //! Number of times this mesh is referenced
         unsigned int instance_cnt;

code/PlyParser.h

@@ -209,7 +209,7 @@ enum EElementSemantic {
 class Property {
 public:
     //! Default constructor
-    Property()
+    Property() AI_NO_EXCEPT
     : eType (EDT_Int)
     , Semantic()
     , bIsList(false)
@@ -257,7 +257,7 @@ public:
 class Element {
 public:
     //! Default constructor
-    Element()
+    Element() AI_NO_EXCEPT
     : eSemantic (EEST_INVALID)
     , NumOccur(0) {
         // empty
@@ -297,8 +297,9 @@ class PropertyInstance
 public:
 
     //! Default constructor
-    PropertyInstance ()
-    {}
+    PropertyInstance() AI_NO_EXCEPT {
+        // empty
+    }
 
     union ValueUnion
     {
@@ -356,13 +357,13 @@ public:
 // ---------------------------------------------------------------------------------
 /** \brief Class for an element instance in a PLY file
  */
-class ElementInstance
-{
+class ElementInstance {
 public:
-
     //! Default constructor
-    ElementInstance ()
-    {}
+    ElementInstance()  AI_NO_EXCEPT
+    : alProperties() {
+        // empty
+    }
 
     //! List of all parsed properties
     std::vector< PropertyInstance > alProperties;
@@ -386,8 +387,10 @@ class ElementInstanceList
 public:
 
     //! Default constructor
-    ElementInstanceList ()
-    {}
+    ElementInstanceList() AI_NO_EXCEPT
+    : alInstances() {
+        // empty
+    }
 
     //! List of all element instances
     std::vector< ElementInstance > alInstances;
@@ -411,8 +414,11 @@ class DOM
 public:
 
     //! Default constructor
-    DOM()
-    {}
+    DOM() AI_NO_EXCEPT
+    : alElements()
+    , alElementData() {
+
+    }
 
 
     //! Contains all elements of the file format

code/PostStepRegistry.cpp

@@ -62,6 +62,9 @@ corresponding preprocessor flag to selectively disable steps.
 #ifndef ASSIMP_BUILD_NO_TRIANGULATE_PROCESS
 #   include "TriangulateProcess.h"
 #endif
+#ifndef ASSIMP_BUILD_NO_DROPFACENORMALS_PROCESS
+#   include "DropFaceNormalsProcess.h"
+#endif
 #ifndef ASSIMP_BUILD_NO_GENFACENORMALS_PROCESS
 #   include "GenFaceNormalsProcess.h"
 #endif
@@ -200,6 +203,9 @@ void GetPostProcessingStepInstanceList(std::vector< BaseProcess* >& out)
 #if (!defined ASSIMP_BUILD_NO_SPLITLARGEMESHES_PROCESS)
     out.push_back( new SplitLargeMeshesProcess_Triangle());
 #endif
+#if (!defined ASSIMP_BUILD_NO_GENFACENORMALS_PROCESS)
+    out.push_back( new DropFaceNormalsProcess());
+#endif
 #if (!defined ASSIMP_BUILD_NO_GENFACENORMALS_PROCESS)
     out.push_back( new GenFaceNormalsProcess());
 #endif

code/Q3BSPFileData.h

@@ -43,7 +43,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #define ASSIMP_Q3BSPFILEDATA_H_INC
 
 #include <vector>
-#include <string.h> //memset
+#include <string.h>
 #include <string>
 
 namespace Assimp {
@@ -77,25 +77,21 @@ struct sQ3BSPHeader {
 };
 
 /// Describes an entry.
-struct sQ3BSPLump
-{
+struct sQ3BSPLump {
     int iOffset;    ///< Offset from start pointer of file
     int iSize;      ///< Size of part
 };
 
-struct vec2f
-{
+struct vec2f {
     float x,y;
 };
 
-struct vec3f
-{
+struct vec3f {
     float x, y, z;
 };
 
 /// Vertex of a Q3 level
-struct sQ3BSPVertex
-{
+struct sQ3BSPVertex {
     vec3f vPosition;    ///< Position of vertex
     vec2f vTexCoord;    ///< (u,v) Texturecoordinate of detailtexture
     vec2f vLightmap;    ///< (u,v) Texturecoordinate of lightmap
@@ -104,8 +100,7 @@ struct sQ3BSPVertex
 };
 
 /// A face in bsp format info
-struct sQ3BSPFace
-{
+struct sQ3BSPFace {
     int iTextureID;                 ///< Index in texture array
     int iEffect;                    ///< Index in effect array (-1 = no effect)
     int iType;                      ///< 1=Polygon, 2=Patch, 3=Mesh, 4=Billboard

code/Q3BSPFileImporter.cpp

@@ -47,6 +47,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "Q3BSPFileParser.h"
 #include "Q3BSPFileData.h"
 
+#include <assimp/DefaultLogger.hpp>
+
 #ifdef ASSIMP_BUILD_NO_OWN_ZLIB
 #   include <zlib.h>
 #else
@@ -82,39 +84,39 @@ using namespace Q3BSP;
 
 // ------------------------------------------------------------------------------------------------
 //  Local function to create a material key name.
-static void createKey( int id1, int id2, std::string &rKey )
-{
+static void createKey( int id1, int id2, std::string &key ) {
     std::ostringstream str;
     str << id1 << "." << id2;
-    rKey = str.str();
+    key = str.str();
 }
 
 // ------------------------------------------------------------------------------------------------
 //  Local function to extract the texture ids from a material key-name.
-static void extractIds( const std::string &rKey, int &rId1, int &rId2 )
-{
-    rId1 = -1;
-    rId2 = -1;
-    if ( rKey.empty() )
+static void extractIds( const std::string &key, int &id1, int &id2 ) {
+    id1 = -1;
+    id2 = -1;
+    if (key.empty()) {
         return;
+    }
 
-    std::string::size_type pos = rKey.find( "." );
-    if ( std::string::npos == pos )
+    const std::string::size_type pos = key.find( "." );
+    if (std::string::npos == pos) {
         return;
+    }
 
-    std::string tmp1 = rKey.substr( 0, pos );
-    std::string tmp2 = rKey.substr( pos + 1, rKey.size() - pos - 1 );
-    rId1 = atoi( tmp1.c_str() );
-    rId2 = atoi( tmp2.c_str() );
+    std::string tmp1 = key.substr( 0, pos );
+    std::string tmp2 = key.substr( pos + 1, key.size() - pos - 1 );
+    id1 = atoi( tmp1.c_str() );
+    id2 = atoi( tmp2.c_str() );
 }
 
 // ------------------------------------------------------------------------------------------------
 //  Local helper function to normalize filenames.
-static void normalizePathName( const std::string &rPath, std::string &rNormalizedPath )
-{
-    rNormalizedPath = "";
-    if ( rPath.empty() )
+static void normalizePathName( const std::string &rPath, std::string &normalizedPath ) {
+    normalizedPath = "";
+    if (rPath.empty()) {
         return;
+    }
 
 #ifdef _WIN32
     std::string sep = "\\";
@@ -124,14 +126,11 @@ static void normalizePathName( const std::string &rPath, std::string &rNormalize
 
     static const unsigned int numDelimiters = 2;
     const char delimiters[ numDelimiters ] = { '/', '\\' };
-    rNormalizedPath = rPath;
-    for (const char delimiter : delimiters)
-    {
-        for ( size_t j=0; j<rNormalizedPath.size(); j++ )
-        {
-            if ( rNormalizedPath[j] == delimiter )
-            {
-                rNormalizedPath[ j ] = sep[ 0 ];
+    normalizedPath = rPath;
+    for (const char delimiter : delimiters) {
+        for ( size_t j=0; j<normalizedPath.size(); ++j ) {
+            if ( normalizedPath[j] == delimiter ) {
+                normalizedPath[ j ] = sep[ 0 ];
             }
         }
     }
@@ -139,20 +138,19 @@ static void normalizePathName( const std::string &rPath, std::string &rNormalize
 
 // ------------------------------------------------------------------------------------------------
 //  Constructor.
-Q3BSPFileImporter::Q3BSPFileImporter() :
-    m_pCurrentMesh( NULL ),
-    m_pCurrentFace( NULL ),
-    m_MaterialLookupMap(),
-    mTextures()
-{
+Q3BSPFileImporter::Q3BSPFileImporter()
+: m_pCurrentMesh( nullptr )
+, m_pCurrentFace(nullptr)
+, m_MaterialLookupMap()
+, mTextures() {
     // empty
 }
 
 // ------------------------------------------------------------------------------------------------
 //  Destructor.
 Q3BSPFileImporter::~Q3BSPFileImporter() {
-    m_pCurrentMesh = NULL;
-    m_pCurrentFace = NULL;
+    m_pCurrentMesh = nullptr;
+    m_pCurrentFace = nullptr;
 
     // Clear face-to-material map
     for ( FaceMap::iterator it = m_MaterialLookupMap.begin(); it != m_MaterialLookupMap.end(); ++it ) {
@@ -166,92 +164,80 @@ Q3BSPFileImporter::~Q3BSPFileImporter() {
 
 // ------------------------------------------------------------------------------------------------
 //  Returns true, if the loader can read this.
-bool Q3BSPFileImporter::CanRead( const std::string& rFile, IOSystem* /*pIOHandler*/, bool checkSig ) const
-{
+bool Q3BSPFileImporter::CanRead( const std::string& rFile, IOSystem* /*pIOHandler*/, bool checkSig ) const {
     if(!checkSig) {
         return SimpleExtensionCheck( rFile, "pk3", "bsp" );
     }
-    // TODO perhaps add keyword based detection
+
     return false;
 }
 
 // ------------------------------------------------------------------------------------------------
 //  Adds extensions.
-const aiImporterDesc* Q3BSPFileImporter::GetInfo () const
-{
+const aiImporterDesc* Q3BSPFileImporter::GetInfo () const {
     return &desc;
 }
 
 // ------------------------------------------------------------------------------------------------
 //  Import method.
-void Q3BSPFileImporter::InternReadFile(const std::string &rFile, aiScene* pScene, IOSystem* pIOHandler)
-{
-    Q3BSPZipArchive Archive( pIOHandler, rFile );
-    if ( !Archive.isOpen() )
-    {
+void Q3BSPFileImporter::InternReadFile(const std::string &rFile, aiScene* scene, IOSystem* ioHandler) {
+    Q3BSPZipArchive Archive( ioHandler, rFile );
+    if ( !Archive.isOpen() ) {
         throw DeadlyImportError( "Failed to open file " + rFile + "." );
     }
 
     std::string archiveName( "" ), mapName( "" );
     separateMapName( rFile, archiveName, mapName );
 
-    if ( mapName.empty() )
-    {
-        if ( !findFirstMapInArchive( Archive, mapName ) )
-        {
+    if ( mapName.empty() ) {
+        if ( !findFirstMapInArchive( Archive, mapName ) ) {
             return;
         }
     }
 
     Q3BSPFileParser fileParser( mapName, &Archive );
     Q3BSPModel *pBSPModel = fileParser.getModel();
-    if ( NULL != pBSPModel )
-    {
-        CreateDataFromImport( pBSPModel, pScene, &Archive );
+    if ( nullptr != pBSPModel ) {
+        CreateDataFromImport( pBSPModel, scene, &Archive );
     }
 }
 
 // ------------------------------------------------------------------------------------------------
 //  Separates the map name from the import name.
-void Q3BSPFileImporter::separateMapName( const std::string &rImportName, std::string &rArchiveName,
-                                        std::string &rMapName )
-{
-    rArchiveName = "";
-    rMapName = "";
-    if ( rImportName.empty() )
+void Q3BSPFileImporter::separateMapName( const std::string &importName, std::string &archiveName, std::string &mapName ) {
+    archiveName = "";
+    mapName = "";
+    if (importName.empty()) {
         return;
+    }
 
-    std::string::size_type pos = rImportName.rfind( "," );
-    if ( std::string::npos == pos )
-    {
-        rArchiveName = rImportName;
+    const std::string::size_type pos = importName.rfind( "," );
+    if ( std::string::npos == pos ) {
+        archiveName = importName;
         return;
     }
 
-    rArchiveName = rImportName.substr( 0, pos );
-    rMapName = rImportName.substr( pos, rImportName.size() - pos - 1 );
+    archiveName = importName.substr( 0, pos );
+    mapName = importName.substr( pos, importName.size() - pos - 1 );
 }
 
 // ------------------------------------------------------------------------------------------------
 //  Returns the first map in the map archive.
-bool Q3BSPFileImporter::findFirstMapInArchive( Q3BSPZipArchive &rArchive, std::string &rMapName )
-{
-    rMapName = "";
+bool Q3BSPFileImporter::findFirstMapInArchive( Q3BSPZipArchive &bspArchive, std::string &mapName ) {
+    mapName = "";
     std::vector<std::string> fileList;
-    rArchive.getFileList( fileList );
-    if ( fileList.empty() )
+    bspArchive.getFileList( fileList );
+    if (fileList.empty()) {
         return false;
+    }
 
-    for ( std::vector<std::string>::iterator it = fileList.begin(); it != fileList.end();
-        ++it )
-    {
-        std::string::size_type pos = (*it).find( "maps/" );
-        if ( std::string::npos != pos )
-        {
+    std::vector<std::string>::iterator it( fileList.begin() );
+    for ( ; it != fileList.end(); ++it ) {
+        const std::string::size_type pos = (*it).find( "maps/" );
+        if ( std::string::npos != pos ) {
             std::string::size_type extPos = (*it).find( ".bsp" );
-            if ( std::string::npos != extPos )
-            {
-                rMapName = *it;
+            if ( std::string::npos != extPos ) {
+                mapName = *it;
                 return true;
             }
         }
@@ -263,14 +249,13 @@ bool Q3BSPFileImporter::findFirstMapInArchive( Q3BSPZipArchive &rArchive, std::s
 // ------------------------------------------------------------------------------------------------
 //  Creates the assimp specific data.
 void Q3BSPFileImporter::CreateDataFromImport( const Q3BSP::Q3BSPModel *pModel, aiScene* pScene,
-                                             Q3BSPZipArchive *pArchive )
-{
-    if ( NULL == pModel || NULL == pScene )
+        Q3BSPZipArchive *pArchive ) {
+    if (nullptr == pModel || nullptr == pScene) {
         return;
+    }
 
     pScene->mRootNode = new aiNode;
-    if ( !pModel->m_ModelName.empty() )
-    {
+    if ( !pModel->m_ModelName.empty() ) {
         pScene->mRootNode->mName.Set( pModel->m_ModelName );
     }
 
@@ -287,47 +272,34 @@ void Q3BSPFileImporter::CreateDataFromImport( const Q3BSP::Q3BSPModel *pModel, a
 // ------------------------------------------------------------------------------------------------
 //  Creates all assimp nodes.
 void Q3BSPFileImporter::CreateNodes( const Q3BSP::Q3BSPModel *pModel, aiScene* pScene,
-                                    aiNode *pParent )
-{
-    ai_assert( NULL != pModel );
-    if ( NULL == pModel )
-    {
+        aiNode *pParent ) {
+    if ( nullptr == pModel ) {
         return;
     }
 
-    unsigned int matIdx = 0;
+    unsigned int matIdx( 0 );
     std::vector<aiMesh*> MeshArray;
     std::vector<aiNode*> NodeArray;
-    for ( FaceMapIt it = m_MaterialLookupMap.begin(); it != m_MaterialLookupMap.end(); ++it )
-    {
+    for ( FaceMapIt it = m_MaterialLookupMap.begin(); it != m_MaterialLookupMap.end(); ++it ) {
         std::vector<Q3BSP::sQ3BSPFace*> *pArray = (*it).second;
         size_t numVerts = countData( *pArray );
-        if ( 0 != numVerts )
-        {
-            aiMesh* pMesh = new aiMesh;
-            aiNode *pNode = CreateTopology( pModel, matIdx, *pArray, pMesh );
-            if ( NULL != pNode )
-            {
+        if ( 0 != numVerts ) {
+            aiMesh *pMesh( nullptr );
+            aiNode *pNode = CreateTopology( pModel, matIdx, *pArray, &pMesh );
+            if ( nullptr != pNode ) {
                 NodeArray.push_back( pNode );
                 MeshArray.push_back( pMesh );
             }
-            else
-            {
-                delete pMesh;
-            }
         }
         matIdx++;
     }
 
     pScene->mNumMeshes = static_cast<unsigned int>( MeshArray.size() );
-    if ( pScene->mNumMeshes > 0 )
-    {
+    if ( pScene->mNumMeshes > 0 ) {
         pScene->mMeshes = new aiMesh*[ pScene->mNumMeshes ];
-        for ( size_t i = 0; i < MeshArray.size(); i++ )
-        {
+        for ( size_t i = 0; i < MeshArray.size(); i++ ) {
             aiMesh *pMesh = MeshArray[ i ];
-            if ( NULL != pMesh )
-            {
+            if ( nullptr != pMesh ) {
                 pScene->mMeshes[ i ] = pMesh;
             }
         }
@@ -335,8 +307,7 @@ void Q3BSPFileImporter::CreateNodes( const Q3BSP::Q3BSPModel *pModel, aiScene* p
 
     pParent->mNumChildren = static_cast<unsigned int>(MeshArray.size());
     pParent->mChildren = new aiNode*[ pScene->mRootNode->mNumChildren ];
-    for ( size_t i=0; i<NodeArray.size(); i++ )
-    {
+    for ( size_t i=0; i<NodeArray.size(); i++ ) {
         aiNode *pNode = NodeArray[ i ];
         pNode->mParent = pParent;
         pParent->mChildren[ i ] = pNode;
@@ -346,54 +317,46 @@ void Q3BSPFileImporter::CreateNodes( const Q3BSP::Q3BSPModel *pModel, aiScene* p
 
 // ------------------------------------------------------------------------------------------------
 //  Creates the topology.
-aiNode *Q3BSPFileImporter::CreateTopology( const Q3BSP::Q3BSPModel *pModel,
-                                          unsigned int materialIdx,
-                                          std::vector<sQ3BSPFace*> &rArray,
-                                          aiMesh* pMesh )
-{
+aiNode *Q3BSPFileImporter::CreateTopology( const Q3BSP::Q3BSPModel *pModel, unsigned int materialIdx,
+        std::vector<sQ3BSPFace*> &rArray, aiMesh **pMesh ) {
     size_t numVerts = countData( rArray );
-    if ( 0 == numVerts )
-    {
-        return NULL;
+    if ( 0 == numVerts ) {
+        return nullptr;
     }
 
     size_t numFaces = countFaces( rArray );
-    if ( 0 == numFaces )
-    {
-        return NULL;
+    if ( 0 == numFaces ) {
+        return nullptr;
     }
 
+    aiMesh *mesh = new aiMesh;
     size_t numTriangles = countTriangles( rArray );
-    pMesh->mPrimitiveTypes = aiPrimitiveType_TRIANGLE;
+    mesh->mPrimitiveTypes = aiPrimitiveType_TRIANGLE;
 
-    pMesh->mFaces = new aiFace[ numTriangles ];
-    pMesh->mNumFaces = static_cast<unsigned int>(numTriangles);
+    mesh->mFaces = new aiFace[ numTriangles ];
+    mesh->mNumFaces = static_cast<unsigned int>(numTriangles);
 
-    pMesh->mNumVertices = static_cast<unsigned int>(numVerts);
-    pMesh->mVertices = new aiVector3D[ numVerts ];
-    pMesh->mNormals =  new aiVector3D[ numVerts ];
-    pMesh->mTextureCoords[ 0 ] = new aiVector3D[ numVerts ];
-    pMesh->mTextureCoords[ 1 ] = new aiVector3D[ numVerts ];
-    pMesh->mMaterialIndex = materialIdx;
+    mesh->mNumVertices = static_cast<unsigned int>(numVerts);
+    mesh->mVertices = new aiVector3D[ numVerts ];
+    mesh->mNormals =  new aiVector3D[ numVerts ];
+    mesh->mTextureCoords[ 0 ] = new aiVector3D[ numVerts ];
+    mesh->mTextureCoords[ 1 ] = new aiVector3D[ numVerts ];
+    mesh->mMaterialIndex = materialIdx;
 
     unsigned int faceIdx = 0;
     unsigned int vertIdx = 0;
-    pMesh->mNumUVComponents[ 0 ] = 2;
-    pMesh->mNumUVComponents[ 1 ] = 2;
-    for ( std::vector<sQ3BSPFace*>::const_iterator it = rArray.begin(); it != rArray.end(); ++it )
-    {
+    mesh->mNumUVComponents[ 0 ] = 2;
+    mesh->mNumUVComponents[ 1 ] = 2;
+    for ( std::vector<sQ3BSPFace*>::const_iterator it = rArray.begin(); it != rArray.end(); ++it ) {
         Q3BSP::sQ3BSPFace *pQ3BSPFace = *it;
         ai_assert( NULL != pQ3BSPFace );
-        if ( NULL == pQ3BSPFace )
-        {
+        if ( nullptr == pQ3BSPFace ) {
             continue;
         }
 
-        if ( pQ3BSPFace->iNumOfFaceVerts > 0 )
-        {
-            if ( pQ3BSPFace->iType == Polygon || pQ3BSPFace->iType == TriangleMesh )
-            {
-                createTriangleTopology( pModel, pQ3BSPFace, pMesh, faceIdx, vertIdx );
+        if ( pQ3BSPFace->iNumOfFaceVerts > 0 ) {
+            if ( pQ3BSPFace->iType == Polygon || pQ3BSPFace->iType == TriangleMesh ) {
+                createTriangleTopology( pModel, pQ3BSPFace, mesh, faceIdx, vertIdx );
             }
         }
     }
@@ -401,79 +364,63 @@ aiNode *Q3BSPFileImporter::CreateTopology( const Q3BSP::Q3BSPModel *pModel,
     aiNode *pNode = new aiNode;
     pNode->mNumMeshes = 1;
     pNode->mMeshes = new unsigned int[ 1 ];
+    *pMesh = mesh;
 
     return pNode;
 }
 
 // ------------------------------------------------------------------------------------------------
 //  Creates the triangle topology from a face array.
-void Q3BSPFileImporter::createTriangleTopology( const Q3BSP::Q3BSPModel *pModel,
-                                              Q3BSP::sQ3BSPFace *pQ3BSPFace,
-                                              aiMesh* pMesh,
-                                              unsigned int &rFaceIdx,
-                                              unsigned int &rVertIdx )
-{
-    ai_assert( rFaceIdx < pMesh->mNumFaces );
+void Q3BSPFileImporter::createTriangleTopology( const Q3BSP::Q3BSPModel *pModel, sQ3BSPFace *pQ3BSPFace,
+        aiMesh* pMesh, unsigned int &faceIdx, unsigned int &vertIdx ) {
+    ai_assert( faceIdx < pMesh->mNumFaces );
 
-    m_pCurrentFace = getNextFace( pMesh, rFaceIdx );
-    ai_assert( NULL != m_pCurrentFace );
-    if ( NULL == m_pCurrentFace )
-    {
+    m_pCurrentFace = getNextFace( pMesh, faceIdx );
+    if ( nullptr == m_pCurrentFace ) {
         return;
     }
 
     m_pCurrentFace->mNumIndices = 3;
     m_pCurrentFace->mIndices = new unsigned int[ m_pCurrentFace->mNumIndices ];
 
-    size_t idx = 0;
-    for ( size_t i = 0; i < (size_t) pQ3BSPFace->iNumOfFaceVerts; i++ )
-    {
+    size_t idx( 0 );
+    for ( size_t i = 0; i < (size_t) pQ3BSPFace->iNumOfFaceVerts; ++i ) {
         const size_t index = pQ3BSPFace->iVertexIndex + pModel->m_Indices[ pQ3BSPFace->iFaceVertexIndex + i ];
-        ai_assert( index < pModel->m_Vertices.size() );
-        if ( index >= pModel->m_Vertices.size() )
-        {
+        if ( index >= pModel->m_Vertices.size() ) {
             continue;
         }
 
         sQ3BSPVertex *pVertex = pModel->m_Vertices[ index ];
-        ai_assert( NULL != pVertex );
-        if ( NULL == pVertex )
-        {
+        if ( nullptr == pVertex ) {
             continue;
         }
+        if (idx > 2) {
+            idx = 0;
+            m_pCurrentFace = getNextFace(pMesh, faceIdx);
+            if (nullptr != m_pCurrentFace) {
+                m_pCurrentFace->mNumIndices = 3;
+                m_pCurrentFace->mIndices = new unsigned int[3];
+            }
+        }
 
-        pMesh->mVertices[ rVertIdx ].Set( pVertex->vPosition.x, pVertex->vPosition.y, pVertex->vPosition.z );
-        pMesh->mNormals[ rVertIdx ].Set( pVertex->vNormal.x, pVertex->vNormal.y, pVertex->vNormal.z );
+        pMesh->mVertices[ vertIdx ].Set( pVertex->vPosition.x, pVertex->vPosition.y, pVertex->vPosition.z );
+        pMesh->mNormals[ vertIdx ].Set( pVertex->vNormal.x, pVertex->vNormal.y, pVertex->vNormal.z );
 
-        pMesh->mTextureCoords[ 0 ][ rVertIdx ].Set( pVertex->vTexCoord.x, pVertex->vTexCoord.y, 0.0f );
-        pMesh->mTextureCoords[ 1 ][ rVertIdx ].Set( pVertex->vLightmap.x, pVertex->vLightmap.y, 0.0f );
+        pMesh->mTextureCoords[ 0 ][ vertIdx ].Set( pVertex->vTexCoord.x, pVertex->vTexCoord.y, 0.0f );
+        pMesh->mTextureCoords[ 1 ][ vertIdx ].Set( pVertex->vLightmap.x, pVertex->vLightmap.y, 0.0f );
 
-        ai_assert( m_pCurrentFace );
-        m_pCurrentFace->mIndices[ idx ] = rVertIdx;
-        rVertIdx++;
+        m_pCurrentFace->mIndices[ idx ] = vertIdx;
+        vertIdx++;
 
         idx++;
-        if ( idx > 2 )
-        {
-            idx = 0;
-            m_pCurrentFace = getNextFace( pMesh, rFaceIdx );
-            if ( NULL != m_pCurrentFace )
-            {
-                m_pCurrentFace->mNumIndices = 3;
-                m_pCurrentFace->mIndices = new unsigned int[ 3 ];
-            }
-        }
     }
-    rFaceIdx--;
 }
 
 // ------------------------------------------------------------------------------------------------
 //  Creates all referenced materials.
 void Q3BSPFileImporter::createMaterials( const Q3BSP::Q3BSPModel *pModel, aiScene* pScene,
-                                        Q3BSPZipArchive *pArchive )
-{
-    if ( m_MaterialLookupMap.empty() )
-    {
+        Q3BSPZipArchive *pArchive ) {
+    if ( m_MaterialLookupMap.empty() ) {
         return;
     }
 
@@ -481,11 +428,9 @@ void Q3BSPFileImporter::createMaterials( const Q3BSP::Q3BSPModel *pModel, aiScen
     aiString aiMatName;
     int textureId( -1 ), lightmapId( -1 );
     for ( FaceMapIt it = m_MaterialLookupMap.begin(); it != m_MaterialLookupMap.end();
-        ++it )
-    {
-        const std::string matName = (*it).first;
-        if ( matName.empty() )
-        {
+        ++it ) {
+        const std::string matName( it->first );
+        if ( matName.empty() ) {
             continue;
         }
 
@@ -496,18 +441,16 @@ void Q3BSPFileImporter::createMaterials( const Q3BSP::Q3BSPModel *pModel, aiScen
         extractIds( matName, textureId, lightmapId );
 
         // Adding the texture
-        if ( -1 != textureId )
-        {
+        if ( -1 != textureId ) {
             sQ3BSPTexture *pTexture = pModel->m_Textures[ textureId ];
-            if ( NULL != pTexture )
-            {
+            if ( nullptr != pTexture ) {
                 std::string tmp( "*" ), texName( "" );
                 tmp += pTexture->strName;
                 tmp += ".jpg";
                 normalizePathName( tmp, texName );
 
-                if ( !importTextureFromArchive( pModel, pArchive, pScene, pMatHelper, textureId ) )
-                {
+                if ( !importTextureFromArchive( pModel, pArchive, pScene, pMatHelper, textureId ) ) {
+                    ASSIMP_LOG_ERROR("Cannot import texture from archive " + texName);
                 }
             }
 
@@ -526,17 +469,16 @@ void Q3BSPFileImporter::createMaterials( const Q3BSP::Q3BSPModel *pModel, aiScen
 
 // ------------------------------------------------------------------------------------------------
 //  Counts the number of referenced vertices.
-size_t Q3BSPFileImporter::countData( const std::vector<sQ3BSPFace*> &rArray ) const
-{
-    size_t numVerts = 0;
-    for ( std::vector<sQ3BSPFace*>::const_iterator it = rArray.begin(); it != rArray.end();
+size_t Q3BSPFileImporter::countData( const std::vector<sQ3BSPFace*> &faceArray ) const {
+    size_t numVerts( 0 );
+    for ( std::vector<sQ3BSPFace*>::const_iterator it = faceArray.begin(); it != faceArray.end();
         ++it )
     {
         sQ3BSPFace *pQ3BSPFace = *it;
         if ( pQ3BSPFace->iType == Polygon || pQ3BSPFace->iType == TriangleMesh )
         {
             Q3BSP::sQ3BSPFace *pQ3BSPFace = *it;
-            ai_assert( NULL != pQ3BSPFace );
+            ai_assert( nullptr != pQ3BSPFace );
             numVerts += pQ3BSPFace->iNumOfFaceVerts;
         }
     }
@@ -582,8 +524,7 @@ size_t Q3BSPFileImporter::countTriangles( const std::vector<Q3BSP::sQ3BSPFace*>
 
 // ------------------------------------------------------------------------------------------------
 //  Creates the faces-to-material map.
-void Q3BSPFileImporter::createMaterialMap( const Q3BSP::Q3BSPModel *pModel )
-{
+void Q3BSPFileImporter::createMaterialMap( const Q3BSP::Q3BSPModel *pModel ) {
     std::string key( "" );
     std::vector<sQ3BSPFace*> *pCurFaceArray = NULL;
     for ( size_t idx = 0; idx < pModel->m_Faces.size(); idx++ )
@@ -593,8 +534,7 @@ void Q3BSPFileImporter::createMaterialMap( const Q3BSP::Q3BSPModel *pModel )
         const int lightMapId = pQ3BSPFace->iLightmapID;
         createKey( texId, lightMapId, key );
         FaceMapIt it = m_MaterialLookupMap.find( key );
-        if ( m_MaterialLookupMap.end() == it )
-        {
+        if ( m_MaterialLookupMap.end() == it ) {
             pCurFaceArray = new std::vector<Q3BSP::sQ3BSPFace*>;
             m_MaterialLookupMap[ key ] = pCurFaceArray;
         }
@@ -602,8 +542,8 @@ void Q3BSPFileImporter::createMaterialMap( const Q3BSP::Q3BSPModel *pModel )
         {
             pCurFaceArray = (*it).second;
         }
-        ai_assert( NULL != pCurFaceArray );
-        if ( NULL != pCurFaceArray )
+        ai_assert( nullptr != pCurFaceArray );
+        if (nullptr != pCurFaceArray )
         {
             pCurFaceArray->push_back( pQ3BSPFace );
         }
@@ -612,32 +552,31 @@ void Q3BSPFileImporter::createMaterialMap( const Q3BSP::Q3BSPModel *pModel )
 
 // ------------------------------------------------------------------------------------------------
 //  Returns the next face.
-aiFace *Q3BSPFileImporter::getNextFace( aiMesh *pMesh, unsigned int &rFaceIdx )
-{
-    aiFace *pFace( NULL );
-    if ( rFaceIdx < pMesh->mNumFaces ) {
-        pFace = &pMesh->mFaces[ rFaceIdx ];
-        rFaceIdx++;
+aiFace *Q3BSPFileImporter::getNextFace( aiMesh *mesh, unsigned int &faceIdx ) {
+    aiFace *face( nullptr );
+    if ( faceIdx < mesh->mNumFaces ) {
+        face = &mesh->mFaces[ faceIdx ];
+        ++faceIdx;
     }
 
-    return pFace;
+    return face;
 }
 
 // ------------------------------------------------------------------------------------------------
 //  Imports a texture file.
-bool Q3BSPFileImporter::importTextureFromArchive( const Q3BSP::Q3BSPModel *pModel,
-                                                 Q3BSP::Q3BSPZipArchive *pArchive, aiScene*,
+bool Q3BSPFileImporter::importTextureFromArchive( const Q3BSP::Q3BSPModel *model,
+                                                 Q3BSP::Q3BSPZipArchive *archive, aiScene*,
                                                  aiMaterial *pMatHelper, int textureId ) {
-    if ( NULL == pArchive || NULL == pMatHelper ) {
+    if (nullptr == archive || nullptr == pMatHelper ) {
         return false;
     }
 
-    if ( textureId < 0 || textureId >= static_cast<int>( pModel->m_Textures.size() ) ) {
+    if ( textureId < 0 || textureId >= static_cast<int>( model->m_Textures.size() ) ) {
         return false;
     }
 
     bool res = true;
-    sQ3BSPTexture *pTexture = pModel->m_Textures[ textureId ];
+    sQ3BSPTexture *pTexture = model->m_Textures[ textureId ];
     if ( !pTexture ) {
         return false;
     }
@@ -647,8 +586,8 @@ bool Q3BSPFileImporter::importTextureFromArchive( const Q3BSP::Q3BSPModel *pMode
     supportedExtensions.push_back( ".png" );
     supportedExtensions.push_back( ".tga" );
     std::string textureName, ext;
-    if ( expandFile( pArchive, pTexture->strName, supportedExtensions, textureName, ext ) ) {
-        IOStream *pTextureStream = pArchive->Open( textureName.c_str() );
+    if ( expandFile( archive, pTexture->strName, supportedExtensions, textureName, ext ) ) {
+        IOStream *pTextureStream = archive->Open( textureName.c_str() );
         if ( pTextureStream ) {
             size_t texSize = pTextureStream->FileSize();
             aiTexture *pTexture = new aiTexture;
@@ -669,7 +608,7 @@ bool Q3BSPFileImporter::importTextureFromArchive( const Q3BSP::Q3BSPModel *pMode
             name.data[ 0 ] = '*';
             name.length = 1 + ASSIMP_itoa10( name.data + 1, static_cast<unsigned int>(MAXLEN-1), static_cast<int32_t>(mTextures.size()) );
 
-            pArchive->Close( pTextureStream );
+            archive->Close( pTextureStream );
 
             pMatHelper->AddProperty( &name, AI_MATKEY_TEXTURE_DIFFUSE( 0 ) );
             mTextures.push_back( pTexture );
@@ -691,19 +630,16 @@ bool Q3BSPFileImporter::importTextureFromArchive( const Q3BSP::Q3BSPModel *pMode
 bool Q3BSPFileImporter::importLightmap( const Q3BSP::Q3BSPModel *pModel, aiScene* pScene,
                                        aiMaterial *pMatHelper, int lightmapId )
 {
-    if ( NULL == pModel || NULL == pScene || NULL == pMatHelper )
-    {
+    if (nullptr == pModel || nullptr == pScene || nullptr == pMatHelper ) {
         return false;
     }
 
-    if ( lightmapId < 0 || lightmapId >= static_cast<int>( pModel->m_Lightmaps.size() ) )
-    {
+    if ( lightmapId < 0 || lightmapId >= static_cast<int>( pModel->m_Lightmaps.size() ) ) {
         return false;
     }
 
     sQ3BSPLightmap *pLightMap = pModel->m_Lightmaps[ lightmapId ];
-    if ( NULL == pLightMap )
-    {
+    if (nullptr == pLightMap ) {
         return false;
     }
 
@@ -715,8 +651,7 @@ bool Q3BSPFileImporter::importLightmap( const Q3BSP::Q3BSPModel *pModel, aiScene
 
     ::memcpy( pTexture->pcData, pLightMap->bLMapData, pTexture->mWidth );
     size_t p = 0;
-    for ( size_t i = 0; i < CE_BSP_LIGHTMAPWIDTH * CE_BSP_LIGHTMAPHEIGHT; ++i )
-    {
+    for ( size_t i = 0; i < CE_BSP_LIGHTMAPWIDTH * CE_BSP_LIGHTMAPHEIGHT; ++i ) {
         pTexture->pcData[ i ].r = pLightMap->bLMapData[ p++ ];
         pTexture->pcData[ i ].g = pLightMap->bLMapData[ p++ ];
         pTexture->pcData[ i ].b = pLightMap->bLMapData[ p++ ];
@@ -733,7 +668,6 @@ bool Q3BSPFileImporter::importLightmap( const Q3BSP::Q3BSPModel *pModel, aiScene
     return true;
 }
 
-
 // ------------------------------------------------------------------------------------------------
 //  Will search for a supported extension.
 bool Q3BSPFileImporter::expandFile(  Q3BSP::Q3BSPZipArchive *pArchive, const std::string &rFilename,

code/Q3BSPFileImporter.h

@@ -45,6 +45,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <assimp/BaseImporter.h>
 
 #include <map>
+#include <string>
 
 struct aiMesh;
 struct aiNode;
@@ -53,6 +54,7 @@ struct aiMaterial;
 struct aiTexture;
 
 namespace Assimp {
+
 namespace Q3BSP {
     class Q3BSPZipArchive;
     struct Q3BSPModel;
@@ -71,12 +73,11 @@ public:
     /// @brief  Destructor.
     ~Q3BSPFileImporter();
 
-public:
     /// @brief  Returns whether the class can handle the format of the given file.
     /// @remark See BaseImporter::CanRead() for details.
     bool CanRead( const std::string& pFile, IOSystem* pIOHandler, bool checkSig ) const;
 
-private:
+protected:
     typedef std::map<std::string, std::vector<Q3BSP::sQ3BSPFace*>*> FaceMap;
     typedef std::map<std::string, std::vector<Q3BSP::sQ3BSPFace*>* >::iterator FaceMapIt;
     typedef std::map<std::string, std::vector<Q3BSP::sQ3BSPFace*>*>::const_iterator FaceMapConstIt;
@@ -88,7 +89,7 @@ private:
     void CreateDataFromImport( const Q3BSP::Q3BSPModel *pModel, aiScene* pScene, Q3BSP::Q3BSPZipArchive *pArchive );
     void CreateNodes( const Q3BSP::Q3BSPModel *pModel, aiScene* pScene, aiNode *pParent );
     aiNode *CreateTopology( const Q3BSP::Q3BSPModel *pModel, unsigned int materialIdx,
-        std::vector<Q3BSP::sQ3BSPFace*> &rArray, aiMesh* pMesh );
+        std::vector<Q3BSP::sQ3BSPFace*> &rArray, aiMesh  **pMesh );
     void createTriangleTopology( const Q3BSP::Q3BSPModel *pModel, Q3BSP::sQ3BSPFace *pQ3BSPFace, aiMesh* pMesh, unsigned int &rFaceIdx,
         unsigned int &rVertIdx  );
     void createMaterials( const Q3BSP::Q3BSPModel *pModel, aiScene* pScene, Q3BSP::Q3BSPZipArchive *pArchive );
@@ -115,5 +116,4 @@ private:
 
 } // Namespace Assimp
 
-
 #endif // ASSIMP_Q3BSPFILEIMPORTER_H_INC

code/Q3BSPFileParser.cpp

@@ -55,56 +55,51 @@ namespace Assimp {
 using namespace Q3BSP;
 
 // ------------------------------------------------------------------------------------------------
-Q3BSPFileParser::Q3BSPFileParser( const std::string &rMapName, Q3BSPZipArchive *pZipArchive ) :
+Q3BSPFileParser::Q3BSPFileParser( const std::string &mapName, Q3BSPZipArchive *pZipArchive ) :
     m_sOffset( 0 ),
     m_Data(),
-    m_pModel( NULL ),
+    m_pModel(nullptr),
     m_pZipArchive( pZipArchive )
 {
-    ai_assert( NULL != m_pZipArchive );
-    ai_assert( !rMapName.empty() );
+    ai_assert(nullptr != m_pZipArchive );
+    ai_assert( !mapName.empty() );
 
-    if ( !readData( rMapName ) )
+    if ( !readData( mapName ) )
         return;
 
     m_pModel = new Q3BSPModel;
-    m_pModel->m_ModelName = rMapName;
-    if ( !parseFile() )
-    {
+    m_pModel->m_ModelName = mapName;
+    if ( !parseFile() ) {
         delete m_pModel;
-        m_pModel = NULL;
+        m_pModel = nullptr;
     }
 }
 
 // ------------------------------------------------------------------------------------------------
-Q3BSPFileParser::~Q3BSPFileParser()
-{
+Q3BSPFileParser::~Q3BSPFileParser() {
     delete m_pModel;
-    m_pModel = NULL;
+    m_pModel = nullptr;
 }
 
 // ------------------------------------------------------------------------------------------------
-Q3BSP::Q3BSPModel *Q3BSPFileParser::getModel() const
-{
+Q3BSP::Q3BSPModel *Q3BSPFileParser::getModel() const {
     return m_pModel;
 }
 
 // ------------------------------------------------------------------------------------------------
-bool Q3BSPFileParser::readData( const std::string &rMapName )
-{
+bool Q3BSPFileParser::readData( const std::string &rMapName ) {
     if ( !m_pZipArchive->Exists( rMapName.c_str() ) )
         return false;
 
     IOStream *pMapFile = m_pZipArchive->Open( rMapName.c_str() );
-    if ( NULL == pMapFile )
+    if ( nullptr == pMapFile )
         return false;
 
     const size_t size = pMapFile->FileSize();
     m_Data.resize( size );
 
     const size_t readSize = pMapFile->Read( &m_Data[0], sizeof( char ), size );
-    if ( readSize != size )
-    {
+    if ( readSize != size ) {
         m_Data.clear();
         return false;
     }
@@ -114,10 +109,8 @@ bool Q3BSPFileParser::readData( const std::string &rMapName )
 }
 
 // ------------------------------------------------------------------------------------------------
-bool Q3BSPFileParser::parseFile()
-{
-    if ( m_Data.empty() )
-    {
+bool Q3BSPFileParser::parseFile() {
+    if ( m_Data.empty() ) {
         return false;
     }
 
@@ -129,7 +122,7 @@ bool Q3BSPFileParser::parseFile()
     // Imports the dictionary of the level
     getLumps();
 
-    // Conunt data and prepare model data
+    // Count data and prepare model data
     countLumps();
 
     // Read in Vertices
@@ -209,7 +202,7 @@ void Q3BSPFileParser::getVertices()
 // ------------------------------------------------------------------------------------------------
 void Q3BSPFileParser::getIndices()
 {
-    ai_assert( NULL != m_pModel );
+    ai_assert(nullptr != m_pModel );
 
     sQ3BSPLump *lump = m_pModel->m_Lumps[ kMeshVerts ];
     size_t Offset = (size_t) lump->iOffset;
@@ -221,7 +214,7 @@ void Q3BSPFileParser::getIndices()
 // ------------------------------------------------------------------------------------------------
 void Q3BSPFileParser::getFaces()
 {
-    ai_assert( NULL != m_pModel );
+    ai_assert(nullptr != m_pModel );
 
     size_t Offset = m_pModel->m_Lumps[ kFaces ]->iOffset;
     for ( size_t idx = 0; idx < m_pModel->m_Faces.size(); idx++ )
@@ -236,7 +229,7 @@ void Q3BSPFileParser::getFaces()
 // ------------------------------------------------------------------------------------------------
 void Q3BSPFileParser::getTextures()
 {
-    ai_assert( NULL != m_pModel );
+    ai_assert(nullptr != m_pModel );
 
     size_t Offset = m_pModel->m_Lumps[ kTextures ]->iOffset;
     for ( size_t idx=0; idx < m_pModel->m_Textures.size(); idx++ )
@@ -251,7 +244,7 @@ void Q3BSPFileParser::getTextures()
 // ------------------------------------------------------------------------------------------------
 void Q3BSPFileParser::getLightMaps()
 {
-    ai_assert( NULL != m_pModel );
+    ai_assert(nullptr != m_pModel );
 
     size_t Offset = m_pModel->m_Lumps[kLightmaps]->iOffset;
     for ( size_t idx=0; idx < m_pModel->m_Lightmaps.size(); idx++ )
@@ -264,12 +257,10 @@ void Q3BSPFileParser::getLightMaps()
 }
 
 // ------------------------------------------------------------------------------------------------
-void Q3BSPFileParser::getEntities()
-{
-    int size = m_pModel->m_Lumps[ kEntities ]->iSize;
+void Q3BSPFileParser::getEntities() {
+    const int size = m_pModel->m_Lumps[ kEntities ]->iSize;
     m_pModel->m_EntityData.resize( size );
-    if ( size > 0 )
-    {
+    if ( size > 0 ) {
         size_t Offset = m_pModel->m_Lumps[ kEntities ]->iOffset;
         memcpy( &m_pModel->m_EntityData[ 0 ], &m_Data[ Offset ], sizeof( char ) * size );
     }

code/Q3BSPZipArchive.cpp

@@ -183,7 +183,7 @@ Q3BSPZipArchive::Q3BSPZipArchive(IOSystem* pIOHandler, const std::string& rFile)
 
         m_ZipFileHandle = unzOpen2(rFile.c_str(), &mapping);
 
-        if(m_ZipFileHandle != NULL) {
+        if(m_ZipFileHandle != nullptr) {
             mapArchive();
         }
     }
@@ -197,26 +197,23 @@ Q3BSPZipArchive::~Q3BSPZipArchive() {
     }
     m_ArchiveMap.clear();
 
-    if(m_ZipFileHandle != NULL) {
+    if(m_ZipFileHandle != nullptr) {
         unzClose(m_ZipFileHandle);
-        m_ZipFileHandle = NULL;
+        m_ZipFileHandle = nullptr;
     }
 }
 
 // ------------------------------------------------------------------------------------------------
 //  Returns true, if the archive is already open.
 bool Q3BSPZipArchive::isOpen() const {
-    return (m_ZipFileHandle != NULL);
+    return (m_ZipFileHandle != nullptr);
 }
 
 // ------------------------------------------------------------------------------------------------
 //  Returns true, if the filename is part of the archive.
 bool Q3BSPZipArchive::Exists(const char* pFile) const {
-    ai_assert(pFile != NULL);
-
     bool exist = false;
-
-    if (pFile != NULL) {
+    if (pFile != nullptr) {
         std::string rFile(pFile);
         std::map<std::string, ZipFile*>::const_iterator it = m_ArchiveMap.find(rFile);
 
@@ -241,9 +238,9 @@ char Q3BSPZipArchive::getOsSeparator() const {
 // ------------------------------------------------------------------------------------------------
 //  Opens a file, which is part of the archive.
 IOStream *Q3BSPZipArchive::Open(const char* pFile, const char* /*pMode*/) {
-    ai_assert(pFile != NULL);
+    ai_assert(pFile != nullptr);
 
-    IOStream* result = NULL;
+    IOStream* result = nullptr;
 
     std::map<std::string, ZipFile*>::iterator it = m_ArchiveMap.find(pFile);
 
@@ -258,7 +255,7 @@ IOStream *Q3BSPZipArchive::Open(const char* pFile, const char* /*pMode*/) {
 //  Close a filestream.
 void Q3BSPZipArchive::Close(IOStream *pFile) {
     (void)(pFile);
-    ai_assert(pFile != NULL);
+    ai_assert(pFile != nullptr);
 
     // We don't do anything in case the file would be opened again in the future
 }
@@ -277,7 +274,7 @@ void Q3BSPZipArchive::getFileList(std::vector<std::string> &rFileList) {
 bool Q3BSPZipArchive::mapArchive() {
     bool success = false;
 
-    if(m_ZipFileHandle != NULL) {
+    if(m_ZipFileHandle != nullptr) {
         if(m_ArchiveMap.empty()) {
             //  At first ensure file is already open
             if(unzGoToFirstFile(m_ZipFileHandle) == UNZ_OK) {

code/SGSpatialSort.h

@@ -1,141 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2017, assimp team
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-
-/** Small helper classes to optimize finding vertices close to a given location
- */
-#ifndef AI_D3DSSPATIALSORT_H_INC
-#define AI_D3DSSPATIALSORT_H_INC
-
-#include <assimp/types.h>
-#include <vector>
-#include <stdint.h>
-
-namespace Assimp    {
-
-// ----------------------------------------------------------------------------------
-/** Specialized version of SpatialSort to support smoothing groups
- *  This is used in by the 3DS, ASE and LWO loaders. 3DS and ASE share their
- *  normal computation code in SmoothingGroups.inl, the LWO loader has its own
- *  implementation to handle all details of its file format correctly.
- */
-// ----------------------------------------------------------------------------------
-class ASSIMP_API SGSpatialSort
-{
-public:
-
-    SGSpatialSort();
-
-    // -------------------------------------------------------------------
-    /** Construction from a given face array, handling smoothing groups
-     *  properly
-     */
-    explicit SGSpatialSort(const std::vector<aiVector3D>& vPositions);
-
-    // -------------------------------------------------------------------
-    /** Add a vertex to the spatial sort
-     * @param vPosition Vertex position to be added
-     * @param index Index of the vrtex
-     * @param smoothingGroup SmoothingGroup for this vertex
-     */
-    void Add(const aiVector3D& vPosition, unsigned int index,
-        unsigned int smoothingGroup);
-
-    // -------------------------------------------------------------------
-    /** Prepare the spatial sorter for use. This step runs in O(logn)
-     */
-    void Prepare();
-
-    /** Destructor */
-    ~SGSpatialSort();
-
-    // -------------------------------------------------------------------
-    /** Returns an iterator for all positions close to the given position.
-     * @param pPosition The position to look for vertices.
-     * @param pSG Only included vertices with at least one shared smooth group
-     * @param pRadius Maximal distance from the position a vertex may have
-     *   to be counted in.
-     * @param poResults The container to store the indices of the found
-     *   positions. Will be emptied by the call so it may contain anything.
-     * @param exactMatch Specifies whether smoothing groups are bit masks
-     *   (false) or integral values (true). In the latter case, a vertex
-     *   cannot belong to more than one smoothing group.
-     * @return An iterator to iterate over all vertices in the given area.
-     */
-    // -------------------------------------------------------------------
-    void FindPositions( const aiVector3D& pPosition, uint32_t pSG,
-        float pRadius, std::vector<unsigned int>& poResults,
-        bool exactMatch = false) const;
-
-protected:
-    /** Normal of the sorting plane, normalized. The center is always at (0, 0, 0) */
-    aiVector3D mPlaneNormal;
-
-    // -------------------------------------------------------------------
-    /** An entry in a spatially sorted position array. Consists of a
-     *  vertex index, its position and its precalculated distance from
-     *  the reference plane */
-    // -------------------------------------------------------------------
-    struct Entry
-    {
-        unsigned int mIndex;    ///< The vertex referred by this entry
-        aiVector3D mPosition;   ///< Position
-        uint32_t mSmoothGroups;
-        float mDistance;        ///< Distance of this vertex to the sorting plane
-
-        Entry() { /** intentionally not initialized.*/ }
-        Entry( unsigned int pIndex, const aiVector3D& pPosition, float pDistance,uint32_t pSG)
-            :
-            mIndex( pIndex),
-            mPosition( pPosition),
-            mSmoothGroups (pSG),
-            mDistance( pDistance)
-            {   }
-
-        bool operator < (const Entry& e) const { return mDistance < e.mDistance; }
-    };
-
-    // all positions, sorted by distance to the sorting plane
-    std::vector<Entry> mPositions;
-};
-
-} // end of namespace Assimp
-
-#endif // AI_SPATIALSORT_H_INC

code/SMDLoader.h

@@ -62,17 +62,17 @@ struct aiNode;
 // STL headers
 #include <vector>
 
-namespace Assimp    {
-
-namespace SMD   {
+namespace Assimp {
+namespace SMD {
 
 // ---------------------------------------------------------------------------
 /** Data structure for a vertex in a SMD file
 */
-struct Vertex
-{
-    Vertex() : iParentNode(UINT_MAX)
-     {}
+struct Vertex {
+    Vertex() AI_NO_EXCEPT
+    : iParentNode(UINT_MAX) {
+        // empty
+    }
 
     //! Vertex position, normal and texture coordinate
     aiVector3D pos,nor,uv;
@@ -90,10 +90,12 @@ struct Vertex
 // ---------------------------------------------------------------------------
 /** Data structure for a face in a SMD file
 */
-struct Face
-{
-    Face() : iTexture(0x0)
-     {}
+struct Face {
+    Face() AI_NO_EXCEPT
+    : iTexture(0x0)
+    , avVertices{} {
+        // empty
+    }
 
     //! Texture index for the face
     unsigned int iTexture;
@@ -105,11 +107,12 @@ struct Face
 // ---------------------------------------------------------------------------
 /** Data structure for a bone in a SMD file
 */
-struct Bone
-{
+struct Bone {
     //! Default constructor
-    Bone() : iParent(UINT_MAX), bIsUsed(false)
-    {
+    Bone() AI_NO_EXCEPT
+    : iParent(UINT_MAX)
+    , bIsUsed(false) {
+        // empty
     }
 
     //! Destructor
@@ -124,12 +127,10 @@ struct Bone
     uint32_t iParent;
 
     //! Animation of the bone
-    struct Animation
-    {
+    struct Animation {
         //! Public default constructor
-        Animation()
-            : iFirstTimeKey()
-        {
+        Animation() AI_NO_EXCEPT
+        : iFirstTimeKey() {
             asKeys.reserve(20);
         }
 
@@ -218,6 +219,7 @@ protected:
     /** Parse the SMD file and create the output scene
     */
     void ParseFile();
+    void ReadSmd(const std::string &pFile, IOSystem* pIOHandler);
 
     // -------------------------------------------------------------------
     /** Parse the triangles section of the SMD file
@@ -288,13 +290,6 @@ protected:
      */
     unsigned int GetTextureIndex(const std::string& filename);
 
-    // -------------------------------------------------------------------
-    /** Computes absolute bone transformations
-     * All output transformations are in worldspace.
-     */
-    void ComputeAbsoluteBoneTransformations();
-
-
     // -------------------------------------------------------------------
     /** Parse a line in the skeleton section
      */
@@ -343,7 +338,9 @@ protected:
      */
     void CreateOutputMeshes();
     void CreateOutputNodes();
-    void CreateOutputAnimations();
+    void CreateOutputAnimations(const std::string &pFile, IOSystem* pIOHandler);
+    void CreateOutputAnimation(int index, const std::string &name);
+    void GetAnimationFileList(const std::string &pFile, IOSystem* pIOHandler, std::vector<std::tuple<std::string, std::string>>& outList);
     void CreateOutputMaterials();
 
 
@@ -412,6 +409,8 @@ private:
      */
     unsigned int iLineNumber;
 
+    bool bLoadAnimationList = true;
+    bool noSkeletonMesh = false;
 };
 
 } // end of namespace Assimp

code/STEPFile.h

@@ -139,10 +139,10 @@ namespace STEP {
      *  error (i.e. an entity expects a string but receives a bool) occurs.
      *  It is typically coupled with both an entity id and a line number.*/
     // -------------------------------------------------------------------------------
-    struct TypeError : DeadlyImportError
-    {
+    struct TypeError : DeadlyImportError {
         enum {
-            ENTITY_NOT_SPECIFIED = 0xffffffffffffffffLL
+            ENTITY_NOT_SPECIFIED = 0xffffffffffffffffLL,
+            ENTITY_NOT_SPECIFIED_32 = 0x00000000ffffffff
         };
 
         TypeError (const std::string& s,uint64_t entity = ENTITY_NOT_SPECIFIED, uint64_t line = SyntaxError::LINE_NOT_SPECIFIED);
@@ -164,7 +164,6 @@ namespace STEP {
         class DataType
         {
         public:
-
             typedef std::shared_ptr<const DataType> Out;
 
         public:
@@ -357,14 +356,25 @@ namespace STEP {
             MemberList members;
         };
 
+        class BINARY : public PrimitiveDataType<uint32_t> {
+        public:
+            BINARY(uint32_t val)
+            : PrimitiveDataType<uint32_t>(val) {
+                // empty
+            }
+
+            BINARY()
+            : PrimitiveDataType<uint32_t>(TypeError::ENTITY_NOT_SPECIFIED_32) {
+                // empty
+            }
+        };
 
         // -------------------------------------------------------------------------------
         /* Not exactly a full EXPRESS schema but rather a list of conversion functions
          * to extract valid C++ objects out of a STEP file. Those conversion functions
          * may, however, perform further schema validations. */
         // -------------------------------------------------------------------------------
-        class ConversionSchema
-        {
+        class ConversionSchema {
         public:
             struct SchemaEntry {
                 SchemaEntry( const char *name, ConvertObjectProc func )
@@ -379,30 +389,27 @@ namespace STEP {
 
             typedef std::map<std::string,ConvertObjectProc> ConverterMap;
 
-        public:
-
             template <size_t N>
             explicit ConversionSchema( const SchemaEntry (& schemas)[N]) {
                 *this = schemas;
             }
 
-            ConversionSchema() {}
+            ConversionSchema() {
 
-        public:
+            }
 
             ConvertObjectProc GetConverterProc(const std::string& name) const {
                 ConverterMap::const_iterator it = converters.find(name);
-                return it == converters.end() ? NULL : (*it).second;
+                return it == converters.end() ? nullptr : (*it).second;
             }
 
-
             bool IsKnownToken(const std::string& name) const {
                 return converters.find(name) != converters.end();
             }
 
             const char* GetStaticStringForToken(const std::string& token) const {
                 ConverterMap::const_iterator it = converters.find(token);
-                return it == converters.end() ? NULL : (*it).first.c_str();
+                return it == converters.end() ? nullptr : (*it).first.c_str();
             }
 
 
@@ -416,7 +423,6 @@ namespace STEP {
             }
 
         private:
-
             ConverterMap converters;
         };
     }
@@ -451,8 +457,6 @@ namespace STEP {
             // empty
         }
 
-    public:
-
         // utilities to simplify casting to concrete types
         template <typename T>
         const T& To() const {
@@ -474,7 +478,6 @@ namespace STEP {
             return dynamic_cast<T*>(this);
         }
 
-    public:
         uint64_t GetID() const {
             return id;
         }
@@ -501,9 +504,11 @@ namespace STEP {
     /** CRTP shared base class for use by concrete entity implementation classes */
     // ------------------------------------------------------------------------------
     template <typename TDerived, size_t arg_count>
-    struct ObjectHelper : virtual Object
-    {
-        ObjectHelper() : aux_is_derived(0) {}
+    struct ObjectHelper : virtual Object {
+        ObjectHelper()
+        : aux_is_derived(0) {
+            // empty
+        }
 
         static Object* Construct(const STEP::DB& db, const EXPRESS::LIST& params) {
             // make sure we don't leak if Fill() throws an exception
@@ -532,10 +537,16 @@ namespace STEP {
     /** Class template used to represent OPTIONAL data members in the converted schema */
     // ------------------------------------------------------------------------------
     template <typename T>
-    struct Maybe
-    {
-        Maybe() : have() {}
-        explicit Maybe(const T& ptr) : ptr(ptr), have(true) {
+    struct Maybe {
+        Maybe()
+        : have() {
+            // empty
+        }
+
+        explicit Maybe(const T& ptr)
+        : ptr(ptr)
+        , have(true) {
+            // empty
         }
 
 
@@ -572,7 +583,6 @@ namespace STEP {
         }
 
     private:
-
         template <typename T2> friend struct InternGenericConvert;
 
         operator T&() {
@@ -587,16 +597,13 @@ namespace STEP {
     /** A LazyObject is created when needed. Before this happens, we just keep
        the text line that contains the object definition. */
     // -------------------------------------------------------------------------------
-    class LazyObject
-    {
+    class LazyObject {
         friend class DB;
-    public:
 
+    public:
         LazyObject(DB& db, uint64_t id, uint64_t line, const char* type,const char* args);
         ~LazyObject();
 
-    public:
-
         Object& operator * () {
             if (!obj) {
                 LazyInit();
@@ -654,38 +661,37 @@ namespace STEP {
         }
 
     private:
-
         void LazyInit() const;
 
     private:
-
         mutable uint64_t id;
         const char* const type;
         DB& db;
-
         mutable const char* args;
         mutable Object* obj;
     };
 
     template <typename T>
-    inline bool operator==( std::shared_ptr<LazyObject> lo, T whatever ) {
+    inline
+    bool operator==( std::shared_ptr<LazyObject> lo, T whatever ) {
         return *lo == whatever; // XXX use std::forward if we have 0x
     }
 
     template <typename T>
-    inline bool operator==( const std::pair<uint64_t, std::shared_ptr<LazyObject> >& lo, T whatever ) {
+    inline
+    bool operator==( const std::pair<uint64_t, std::shared_ptr<LazyObject> >& lo, T whatever ) {
         return *(lo.second) == whatever; // XXX use std::forward if we have 0x
     }
 
-
     // ------------------------------------------------------------------------------
     /** Class template used to represent lazily evaluated object references in the converted schema */
     // ------------------------------------------------------------------------------
     template <typename T>
-    struct Lazy
-    {
+    struct Lazy {
         typedef Lazy Out;
-        Lazy(const LazyObject* obj = NULL) : obj(obj) {
+        Lazy(const LazyObject* obj = nullptr)
+        : obj(obj) {
+            // empty
         }
 
         operator const T*() const {
@@ -711,19 +717,15 @@ namespace STEP {
     /** Class template used to represent LIST and SET data members in the converted schema */
     // ------------------------------------------------------------------------------
     template <typename T, uint64_t min_cnt, uint64_t max_cnt=0uL>
-    struct ListOf : public std::vector<typename T::Out>
-    {
+    struct ListOf : public std::vector<typename T::Out> {
         typedef typename T::Out OutScalar;
         typedef ListOf Out;
 
-
         ListOf() {
             static_assert(min_cnt <= max_cnt || !max_cnt, "min_cnt <= max_cnt || !max_cnt");
         }
-
     };
 
-
     // ------------------------------------------------------------------------------
     template <typename TOut>
     struct PickBaseType {
@@ -735,7 +737,8 @@ namespace STEP {
         typedef EXPRESS::ENTITY Type;
     };
 
-    template <> struct PickBaseType< std::shared_ptr< const EXPRESS::DataType > >;
+    template<>
+    struct PickBaseType< std::shared_ptr< const EXPRESS::DataType > >;
 
     // ------------------------------------------------------------------------------
     template <typename T>
@@ -743,8 +746,7 @@ namespace STEP {
         void operator()(T& out, const std::shared_ptr< const EXPRESS::DataType >& in, const STEP::DB& /*db*/) {
             try{
                 out = dynamic_cast< const typename PickBaseType<T>::Type& > ( *in );
-            }
-            catch(std::bad_cast&) {
+            } catch(std::bad_cast&) {
                 throw TypeError("type error reading literal field");
             }
         }
@@ -817,7 +819,6 @@ namespace STEP {
         return InternGenericConvertList<T1,N1,N2>()(a,b,db);
     }
 
-
     // ------------------------------------------------------------------------------
     /** Lightweight manager class that holds the map of all objects in a
      *  STEP file. DB's are exclusively maintained by the functions in
@@ -834,7 +835,6 @@ namespace STEP {
         friend class LazyObject;
 
     public:
-
         // objects indexed by ID - this can grow pretty large (i.e some hundred million
         // entries), so use raw pointers to avoid *any* overhead.
         typedef std::map<uint64_t,const LazyObject* > ObjectMap;
@@ -859,19 +859,16 @@ namespace STEP {
             : reader(reader)
             , splitter(*reader,true,true)
             , evaluated_count()
-            , schema( NULL )
+            , schema( nullptr )
         {}
 
     public:
-
         ~DB() {
             for(ObjectMap::value_type& o : objects) {
                 delete o.second;
             }
         }
 
-    public:
-
         uint64_t GetObjectCount() const {
             return objects.size();
         }
@@ -900,7 +897,6 @@ namespace STEP {
             return refs;
         }
 
-
         bool KeepInverseIndicesForType(const char* const type) const {
             return inv_whitelist.find(type) != inv_whitelist.end();
         }
@@ -912,7 +908,7 @@ namespace STEP {
             if (it != objects.end()) {
                 return (*it).second;
             }
-            return NULL;
+            return nullptr;
         }
 
 

code/STLLoader.cpp

@@ -214,11 +214,10 @@ void STLImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOS
 
     // create a single default material, using a white diffuse color for consistency with
     // other geometric types (e.g., PLY).
-    aiMaterial* pcMat = aiCreateAndRegisterDefaultMaterial();
-    /*aiMaterial* pcMat = new aiMaterial();
+    aiMaterial* pcMat = new aiMaterial();
     aiString s;
     s.Set(AI_DEFAULT_MATERIAL_NAME);
-    pcMat->AddProperty(&s, AI_MATKEY_NAME);*/
+    pcMat->AddProperty(&s, AI_MATKEY_NAME);
 
     aiColor4D clrDiffuse(ai_real(1.0),ai_real(1.0),ai_real(1.0),ai_real(1.0));
     if (bMatClr) {

code/ScenePrivate.h

@@ -56,7 +56,7 @@ class Importer;
 
 struct ScenePrivateData {
     //  The struct constructor.
-    ScenePrivateData();
+    ScenePrivateData() AI_NO_EXCEPT;
 
     // Importer that originally loaded the scene though the C-API
     // If set, this object is owned by this private data instance.
@@ -74,7 +74,7 @@ struct ScenePrivateData {
 };
 
 inline
-ScenePrivateData::ScenePrivateData()
+ScenePrivateData::ScenePrivateData() AI_NO_EXCEPT
 : mOrigImporter( nullptr )
 , mPPStepsApplied( 0 )
 , mIsCopy( false ) {

code/SplitLargeMeshes.cpp

@@ -40,11 +40,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ----------------------------------------------------------------------
 */
 
-
-/** @file Implementation of the SplitLargeMeshes postprocessing step
-*/
-
-
+/** 
+ *  @file Implementation of the SplitLargeMeshes postprocessing step
+ */
 
 // internal headers of the post-processing framework
 #include "SplitLargeMeshes.h"
@@ -52,61 +50,57 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 using namespace Assimp;
 
-
 // ------------------------------------------------------------------------------------------------
-SplitLargeMeshesProcess_Triangle::SplitLargeMeshesProcess_Triangle()
-{
+SplitLargeMeshesProcess_Triangle::SplitLargeMeshesProcess_Triangle() {
     LIMIT = AI_SLM_DEFAULT_MAX_TRIANGLES;
 }
 
 // ------------------------------------------------------------------------------------------------
-SplitLargeMeshesProcess_Triangle::~SplitLargeMeshesProcess_Triangle()
-{
+SplitLargeMeshesProcess_Triangle::~SplitLargeMeshesProcess_Triangle() {
     // nothing to do here
 }
 
 // ------------------------------------------------------------------------------------------------
 // Returns whether the processing step is present in the given flag field.
-bool SplitLargeMeshesProcess_Triangle::IsActive( unsigned int pFlags) const
-{
+bool SplitLargeMeshesProcess_Triangle::IsActive( unsigned int pFlags) const {
     return (pFlags & aiProcess_SplitLargeMeshes) != 0;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Executes the post processing step on the given imported data.
-void SplitLargeMeshesProcess_Triangle::Execute( aiScene* pScene)
-{
-    if (0xffffffff == this->LIMIT)return;
+void SplitLargeMeshesProcess_Triangle::Execute( aiScene* pScene) {
+    if (0xffffffff == this->LIMIT || nullptr == pScene ) {
+        return;
+    }
 
     ASSIMP_LOG_DEBUG("SplitLargeMeshesProcess_Triangle begin");
     std::vector<std::pair<aiMesh*, unsigned int> > avList;
 
-    for( unsigned int a = 0; a < pScene->mNumMeshes; a++)
+    for( unsigned int a = 0; a < pScene->mNumMeshes; ++a) {
         this->SplitMesh(a, pScene->mMeshes[a],avList);
+    }
 
-    if (avList.size() != pScene->mNumMeshes)
-    {
+    if (avList.size() != pScene->mNumMeshes) {
         // it seems something has been split. rebuild the mesh list
         delete[] pScene->mMeshes;
         pScene->mNumMeshes = (unsigned int)avList.size();
         pScene->mMeshes = new aiMesh*[avList.size()];
 
-        for (unsigned int i = 0; i < avList.size();++i)
+        for (unsigned int i = 0; i < avList.size();++i) {
             pScene->mMeshes[i] = avList[i].first;
+        }
 
         // now we need to update all nodes
         this->UpdateNode(pScene->mRootNode,avList);
         ASSIMP_LOG_INFO("SplitLargeMeshesProcess_Triangle finished. Meshes have been split");
-    }
-    else {
+    } else {
         ASSIMP_LOG_DEBUG("SplitLargeMeshesProcess_Triangle finished. There was nothing to do");
     }
 }
 
 // ------------------------------------------------------------------------------------------------
 // Setup properties
-void SplitLargeMeshesProcess_Triangle::SetupProperties( const Importer* pImp)
-{
+void SplitLargeMeshesProcess_Triangle::SetupProperties( const Importer* pImp) {
     // get the current value of the split property
     this->LIMIT = pImp->GetPropertyInteger(AI_CONFIG_PP_SLM_TRIANGLE_LIMIT,AI_SLM_DEFAULT_MAX_TRIANGLES);
 }
@@ -114,17 +108,13 @@ void SplitLargeMeshesProcess_Triangle::SetupProperties( const Importer* pImp)
 // ------------------------------------------------------------------------------------------------
 // Update a node after some meshes have been split
 void SplitLargeMeshesProcess_Triangle::UpdateNode(aiNode* pcNode,
-    const std::vector<std::pair<aiMesh*, unsigned int> >& avList)
-{
+        const std::vector<std::pair<aiMesh*, unsigned int> >& avList) {
     // for every index in out list build a new entry
     std::vector<unsigned int> aiEntries;
     aiEntries.reserve(pcNode->mNumMeshes + 1);
-    for (unsigned int i = 0; i < pcNode->mNumMeshes;++i)
-    {
-        for (unsigned int a = 0; a < avList.size();++a)
-        {
-            if (avList[a].second == pcNode->mMeshes[i])
-            {
+    for (unsigned int i = 0; i < pcNode->mNumMeshes;++i) {
+        for (unsigned int a = 0; a < avList.size();++a) {
+            if (avList[a].second == pcNode->mMeshes[i]) {
                 aiEntries.push_back(a);
             }
         }
@@ -135,26 +125,23 @@ void SplitLargeMeshesProcess_Triangle::UpdateNode(aiNode* pcNode,
     pcNode->mNumMeshes = (unsigned int)aiEntries.size();
     pcNode->mMeshes = new unsigned int[pcNode->mNumMeshes];
 
-    for (unsigned int b = 0; b < pcNode->mNumMeshes;++b)
+    for (unsigned int b = 0; b < pcNode->mNumMeshes;++b) {
         pcNode->mMeshes[b] = aiEntries[b];
+    }
 
     // recusively update all other nodes
-    for (unsigned int i = 0; i < pcNode->mNumChildren;++i)
-    {
+    for (unsigned int i = 0; i < pcNode->mNumChildren;++i) {
         UpdateNode ( pcNode->mChildren[i], avList );
     }
-    return;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Executes the post processing step on the given imported data.
 void SplitLargeMeshesProcess_Triangle::SplitMesh(
-    unsigned int a,
-    aiMesh* pMesh,
-    std::vector<std::pair<aiMesh*, unsigned int> >& avList)
-{
-    if (pMesh->mNumFaces > SplitLargeMeshesProcess_Triangle::LIMIT)
-    {
+        unsigned int a,
+        aiMesh* pMesh,
+        std::vector<std::pair<aiMesh*, unsigned int> >& avList) {
+    if (pMesh->mNumFaces > SplitLargeMeshesProcess_Triangle::LIMIT) {
         ASSIMP_LOG_INFO("Mesh exceeds the triangle limit. It will be split ...");
 
         // we need to split this mesh into sub meshes
@@ -165,8 +152,7 @@ void SplitLargeMeshesProcess_Triangle::SplitMesh(
         const unsigned int iOutVertexNum = iOutFaceNum * 3;
 
         // now generate all submeshes
-        for (unsigned int i = 0; i < iSubMeshes;++i)
-        {
+        for (unsigned int i = 0; i < iSubMeshes;++i) {
             aiMesh* pcMesh          = new aiMesh;
             pcMesh->mNumFaces       = iOutFaceNum;
             pcMesh->mMaterialIndex  = pMesh->mMaterialIndex;
@@ -174,8 +160,7 @@ void SplitLargeMeshesProcess_Triangle::SplitMesh(
             // the name carries the adjacency information between the meshes
             pcMesh->mName = pMesh->mName;
 
-            if (i == iSubMeshes-1)
-            {
+            if (i == iSubMeshes-1) {
                 pcMesh->mNumFaces = iOutFaceNum + (
                     pMesh->mNumFaces - iOutFaceNum * iSubMeshes);
             }
@@ -186,71 +171,62 @@ void SplitLargeMeshesProcess_Triangle::SplitMesh(
 
             // get the total number of indices
             unsigned int iCnt = 0;
-            for (unsigned int p = iBase; p < pcMesh->mNumFaces + iBase;++p)
-            {
+            for (unsigned int p = iBase; p < pcMesh->mNumFaces + iBase;++p) {
                 iCnt += pMesh->mFaces[p].mNumIndices;
             }
             pcMesh->mNumVertices = iCnt;
 
             // allocate storage
-            if (pMesh->mVertices != NULL)
+            if (pMesh->mVertices != nullptr) {
                 pcMesh->mVertices = new aiVector3D[iCnt];
+            }
 
-            if (pMesh->HasNormals())
+            if (pMesh->HasNormals()) {
                 pcMesh->mNormals = new aiVector3D[iCnt];
+            }
 
-            if (pMesh->HasTangentsAndBitangents())
-            {
+            if (pMesh->HasTangentsAndBitangents()) {
                 pcMesh->mTangents = new aiVector3D[iCnt];
                 pcMesh->mBitangents = new aiVector3D[iCnt];
             }
 
             // texture coordinates
-            for (unsigned int c = 0;  c < AI_MAX_NUMBER_OF_TEXTURECOORDS;++c)
-            {
+            for (unsigned int c = 0;  c < AI_MAX_NUMBER_OF_TEXTURECOORDS;++c) {
                 pcMesh->mNumUVComponents[c] = pMesh->mNumUVComponents[c];
-                if (pMesh->HasTextureCoords( c))
-                {
+                if (pMesh->HasTextureCoords( c)) {
                     pcMesh->mTextureCoords[c] = new aiVector3D[iCnt];
                 }
             }
 
             // vertex colors
-            for (unsigned int c = 0;  c < AI_MAX_NUMBER_OF_COLOR_SETS;++c)
-            {
-                if (pMesh->HasVertexColors( c))
-                {
+            for (unsigned int c = 0;  c < AI_MAX_NUMBER_OF_COLOR_SETS;++c) {
+                if (pMesh->HasVertexColors( c)) {
                     pcMesh->mColors[c] = new aiColor4D[iCnt];
                 }
             }
 
-            if (pMesh->HasBones())
-            {
+            if (pMesh->HasBones()) {
                 // assume the number of bones won't change in most cases
                 pcMesh->mBones = new aiBone*[pMesh->mNumBones];
 
                 // iterate through all bones of the mesh and find those which
                 // need to be copied to the split mesh
                 std::vector<aiVertexWeight> avTempWeights;
-                for (unsigned int p = 0; p < pcMesh->mNumBones;++p)
-                {
+                for (unsigned int p = 0; p < pcMesh->mNumBones;++p) {
                     aiBone* const bone = pcMesh->mBones[p];
                     avTempWeights.clear();
                     avTempWeights.reserve(bone->mNumWeights / iSubMeshes);
 
-                    for (unsigned int q = 0; q < bone->mNumWeights;++q)
-                    {
+                    for (unsigned int q = 0; q < bone->mNumWeights;++q) {
                         aiVertexWeight& weight = bone->mWeights[q];
-                        if(weight.mVertexId >= iBase && weight.mVertexId < iBase + iOutVertexNum)
-                        {
+                        if(weight.mVertexId >= iBase && weight.mVertexId < iBase + iOutVertexNum) {
                             avTempWeights.push_back(weight);
                             weight = avTempWeights.back();
                             weight.mVertexId -= iBase;
                         }
                     }
 
-                    if (!avTempWeights.empty())
-                    {
+                    if (!avTempWeights.empty()) {
                         // we'll need this bone. Copy it ...
                         aiBone* pc = new aiBone();
                         pcMesh->mBones[pcMesh->mNumBones++] = pc;
@@ -261,12 +237,12 @@ void SplitLargeMeshesProcess_Triangle::SplitMesh(
                         // no need to reallocate the array for the last submesh.
                         // Here we can reuse the (large) source array, although
                         // we'll waste some memory
-                        if (iSubMeshes-1 == i)
-                        {
+                        if (iSubMeshes-1 == i) {
                             pc->mWeights = bone->mWeights;
-                            bone->mWeights = NULL;
+                            bone->mWeights = nullptr;
+                        } else {
+                            pc->mWeights = new aiVertexWeight[pc->mNumWeights];
                         }
-                        else pc->mWeights = new aiVertexWeight[pc->mNumWeights];
 
                         // copy the weights
                         ::memcpy(pc->mWeights,&avTempWeights[0],sizeof(aiVertexWeight)*pc->mNumWeights);
@@ -276,8 +252,7 @@ void SplitLargeMeshesProcess_Triangle::SplitMesh(
 
             // (we will also need to copy the array of indices)
             unsigned int iCurrent = 0;
-            for (unsigned int p = 0; p < pcMesh->mNumFaces;++p)
-            {
+            for (unsigned int p = 0; p < pcMesh->mNumFaces;++p) {
                 pcMesh->mFaces[p].mNumIndices = 3;
                 // allocate a new array
                 const unsigned int iTemp = p + iBase;
@@ -289,8 +264,7 @@ void SplitLargeMeshesProcess_Triangle::SplitMesh(
                 unsigned int* piOut = pcMesh->mFaces[p].mIndices = new unsigned int[iNumIndices];
 
                 // need to update the output primitive types
-                switch (iNumIndices)
-                {
+                switch (iNumIndices) {
                 case 1:
                     pcMesh->mPrimitiveTypes |= aiPrimitiveType_POINT;
                     break;
@@ -305,38 +279,38 @@ void SplitLargeMeshesProcess_Triangle::SplitMesh(
                 }
 
                 // and copy the contents of the old array, offset by current base
-                for (unsigned int v = 0; v < iNumIndices;++v)
-                {
+                for (unsigned int v = 0; v < iNumIndices;++v) {
                     unsigned int iIndex = pi[v];
                     unsigned int iIndexOut = iCurrent++;
                     piOut[v] = iIndexOut;
 
                     // copy positions
-                    if (pMesh->mVertices != NULL)
+                    if (pMesh->mVertices != nullptr) {
                         pcMesh->mVertices[iIndexOut] = pMesh->mVertices[iIndex];
+                    }
 
                     // copy normals
-                    if (pMesh->HasNormals())
+                    if (pMesh->HasNormals()) {
                         pcMesh->mNormals[iIndexOut] = pMesh->mNormals[iIndex];
+                    }
 
                     // copy tangents/bitangents
-                    if (pMesh->HasTangentsAndBitangents())
-                    {
+                    if (pMesh->HasTangentsAndBitangents()) {
                         pcMesh->mTangents[iIndexOut] = pMesh->mTangents[iIndex];
                         pcMesh->mBitangents[iIndexOut] = pMesh->mBitangents[iIndex];
                     }
 
                     // texture coordinates
-                    for (unsigned int c = 0;  c < AI_MAX_NUMBER_OF_TEXTURECOORDS;++c)
-                    {
-                        if (pMesh->HasTextureCoords( c))
+                    for (unsigned int c = 0;  c < AI_MAX_NUMBER_OF_TEXTURECOORDS;++c) {
+                        if (pMesh->HasTextureCoords( c ) ) {
                             pcMesh->mTextureCoords[c][iIndexOut] = pMesh->mTextureCoords[c][iIndex];
+                        }
                     }
                     // vertex colors
-                    for (unsigned int c = 0;  c < AI_MAX_NUMBER_OF_COLOR_SETS;++c)
-                    {
-                        if (pMesh->HasVertexColors( c))
+                    for (unsigned int c = 0;  c < AI_MAX_NUMBER_OF_COLOR_SETS;++c) {
+                        if (pMesh->HasVertexColors( c)) {
                             pcMesh->mColors[c][iIndexOut] = pMesh->mColors[c][iIndex];
+                        }
                     }
                 }
             }
@@ -347,51 +321,59 @@ void SplitLargeMeshesProcess_Triangle::SplitMesh(
 
         // now delete the old mesh data
         delete pMesh;
+    } else {
+        avList.push_back(std::pair<aiMesh*, unsigned int>(pMesh,a));
     }
-    else avList.push_back(std::pair<aiMesh*, unsigned int>(pMesh,a));
-    return;
 }
 
 // ------------------------------------------------------------------------------------------------
-SplitLargeMeshesProcess_Vertex::SplitLargeMeshesProcess_Vertex()
-{
+SplitLargeMeshesProcess_Vertex::SplitLargeMeshesProcess_Vertex() {
     LIMIT = AI_SLM_DEFAULT_MAX_VERTICES;
 }
 
 // ------------------------------------------------------------------------------------------------
-SplitLargeMeshesProcess_Vertex::~SplitLargeMeshesProcess_Vertex()
-{
+SplitLargeMeshesProcess_Vertex::~SplitLargeMeshesProcess_Vertex() {
     // nothing to do here
 }
 
 // ------------------------------------------------------------------------------------------------
 // Returns whether the processing step is present in the given flag field.
-bool SplitLargeMeshesProcess_Vertex::IsActive( unsigned int pFlags) const
-{
+bool SplitLargeMeshesProcess_Vertex::IsActive( unsigned int pFlags) const {
     return (pFlags & aiProcess_SplitLargeMeshes) != 0;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Executes the post processing step on the given imported data.
-void SplitLargeMeshesProcess_Vertex::Execute( aiScene* pScene)
-{
+void SplitLargeMeshesProcess_Vertex::Execute( aiScene* pScene) {
+    if (0xffffffff == this->LIMIT || nullptr == pScene ) {
+        return;
+    }
+
+    ASSIMP_LOG_DEBUG("SplitLargeMeshesProcess_Vertex begin");
+
     std::vector<std::pair<aiMesh*, unsigned int> > avList;
 
-    if (0xffffffff == this->LIMIT)return;
+    //Check for point cloud first, 
+    //Do not process point cloud, splitMesh works only with faces data
+    for (unsigned int a = 0; a < pScene->mNumMeshes; a++) {
+        if ( pScene->mMeshes[a]->mPrimitiveTypes == aiPrimitiveType_POINT ) {
+            return;
+        }
+    }
 
-    ASSIMP_LOG_DEBUG("SplitLargeMeshesProcess_Vertex begin");
-    for( unsigned int a = 0; a < pScene->mNumMeshes; a++)
-        this->SplitMesh(a, pScene->mMeshes[a],avList);
+    for( unsigned int a = 0; a < pScene->mNumMeshes; ++a ) {
+        this->SplitMesh(a, pScene->mMeshes[a], avList);
+    }
 
-    if (avList.size() != pScene->mNumMeshes)
-    {
+    if (avList.size() != pScene->mNumMeshes) {
         // it seems something has been split. rebuild the mesh list
         delete[] pScene->mMeshes;
         pScene->mNumMeshes = (unsigned int)avList.size();
         pScene->mMeshes = new aiMesh*[avList.size()];
 
-        for (unsigned int i = 0; i < avList.size();++i)
+        for (unsigned int i = 0; i < avList.size();++i) {
             pScene->mMeshes[i] = avList[i].first;
+        }
 
         // now we need to update all nodes
         SplitLargeMeshesProcess_Triangle::UpdateNode(pScene->mRootNode,avList);
@@ -403,20 +385,17 @@ void SplitLargeMeshesProcess_Vertex::Execute( aiScene* pScene)
 
 // ------------------------------------------------------------------------------------------------
 // Setup properties
-void SplitLargeMeshesProcess_Vertex::SetupProperties( const Importer* pImp)
-{
+void SplitLargeMeshesProcess_Vertex::SetupProperties( const Importer* pImp) {
     this->LIMIT = pImp->GetPropertyInteger(AI_CONFIG_PP_SLM_VERTEX_LIMIT,AI_SLM_DEFAULT_MAX_VERTICES);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Executes the post processing step on the given imported data.
 void SplitLargeMeshesProcess_Vertex::SplitMesh(
-    unsigned int a,
-    aiMesh* pMesh,
-    std::vector<std::pair<aiMesh*, unsigned int> >& avList)
-{
-    if (pMesh->mNumVertices > SplitLargeMeshesProcess_Vertex::LIMIT)
-    {
+        unsigned int a,
+        aiMesh* pMesh,
+        std::vector<std::pair<aiMesh*, unsigned int> >& avList) {
+    if (pMesh->mNumVertices > SplitLargeMeshesProcess_Vertex::LIMIT) {
         typedef std::vector< std::pair<unsigned int,float> > VertexWeightTable;
 
         // build a per-vertex weight list if necessary
@@ -426,7 +405,6 @@ void SplitLargeMeshesProcess_Vertex::SplitMesh(
         // determine the estimated size of a submesh
         // (this could be too large. Max waste is a single digit percentage)
         const unsigned int iSubMeshes = (pMesh->mNumVertices / SplitLargeMeshesProcess_Vertex::LIMIT) + 1;
-        //const unsigned int iOutVertexNum2 = pMesh->mNumVertices /iSubMeshes;
 
         // create a std::vector<unsigned int> to indicate which vertices
         // have already been copied
@@ -439,11 +417,9 @@ void SplitLargeMeshesProcess_Vertex::SplitMesh(
         iEstimatedSize += iEstimatedSize >> 3;
 
         // now generate all submeshes
-        unsigned int iBase = 0;
-        while (true)
-        {
+        unsigned int iBase( 0 );
+        while (true) {
             const unsigned int iOutVertexNum = SplitLargeMeshesProcess_Vertex::LIMIT;
-
             aiMesh* pcMesh          = new aiMesh;
             pcMesh->mNumVertices    = 0;
             pcMesh->mMaterialIndex  = pMesh->mMaterialIndex;
@@ -452,18 +428,15 @@ void SplitLargeMeshesProcess_Vertex::SplitMesh(
             pcMesh->mName = pMesh->mName;
 
             typedef std::vector<aiVertexWeight> BoneWeightList;
-            if (pMesh->HasBones())
-            {
+            if (pMesh->HasBones()) {
                 pcMesh->mBones = new aiBone*[pMesh->mNumBones];
                 ::memset(pcMesh->mBones,0,sizeof(void*)*pMesh->mNumBones);
             }
 
             // clear the temporary helper array
-            if (iBase)
-            {
+            if (iBase) {
                 // we can't use memset here we unsigned int needn' be 32 bits
-                for (auto &elem : avWasCopied)
-                {
+                for (auto &elem : avWasCopied) {
                     elem = 0xffffffff;
                 }
             }
@@ -472,50 +445,41 @@ void SplitLargeMeshesProcess_Vertex::SplitMesh(
             std::vector<aiFace> vFaces;
 
             // reserve enough storage for most cases
-            if (pMesh->HasPositions())
-            {
+            if (pMesh->HasPositions()) {
                 pcMesh->mVertices = new aiVector3D[iOutVertexNum];
             }
-            if (pMesh->HasNormals())
-            {
+            if (pMesh->HasNormals()) {
                 pcMesh->mNormals = new aiVector3D[iOutVertexNum];
             }
-            if (pMesh->HasTangentsAndBitangents())
-            {
+            if (pMesh->HasTangentsAndBitangents()) {
                 pcMesh->mTangents = new aiVector3D[iOutVertexNum];
                 pcMesh->mBitangents = new aiVector3D[iOutVertexNum];
             }
-            for (unsigned int c = 0; pMesh->HasVertexColors(c);++c)
-            {
+            for (unsigned int c = 0; pMesh->HasVertexColors(c);++c) {
                 pcMesh->mColors[c] = new aiColor4D[iOutVertexNum];
             }
-            for (unsigned int c = 0; pMesh->HasTextureCoords(c);++c)
-            {
+            for (unsigned int c = 0; pMesh->HasTextureCoords(c);++c) {
                 pcMesh->mNumUVComponents[c] = pMesh->mNumUVComponents[c];
                 pcMesh->mTextureCoords[c] = new aiVector3D[iOutVertexNum];
             }
             vFaces.reserve(iEstimatedSize);
 
             // (we will also need to copy the array of indices)
-            while (iBase < pMesh->mNumFaces)
-            {
+            while (iBase < pMesh->mNumFaces) {
                 // allocate a new array
                 const unsigned int iNumIndices = pMesh->mFaces[iBase].mNumIndices;
 
                 // doesn't catch degenerates but is quite fast
                 unsigned int iNeed = 0;
-                for (unsigned int v = 0; v < iNumIndices;++v)
-                {
+                for (unsigned int v = 0; v < iNumIndices;++v) {
                     unsigned int iIndex = pMesh->mFaces[iBase].mIndices[v];
 
                     // check whether we do already have this vertex
-                    if (0xFFFFFFFF == avWasCopied[iIndex])
-                    {
+                    if (0xFFFFFFFF == avWasCopied[iIndex]) {
                         iNeed++;
                     }
                 }
-                if (pcMesh->mNumVertices + iNeed > iOutVertexNum)
-                {
+                if (pcMesh->mNumVertices + iNeed > iOutVertexNum) {
                     // don't use this face
                     break;
                 }
@@ -528,8 +492,7 @@ void SplitLargeMeshesProcess_Vertex::SplitMesh(
                 rFace.mIndices = new unsigned int[iNumIndices];
 
                 // need to update the output primitive types
-                switch (rFace.mNumIndices)
-                {
+                switch (rFace.mNumIndices) {
                 case 1:
                     pcMesh->mPrimitiveTypes |= aiPrimitiveType_POINT;
                     break;
@@ -544,13 +507,11 @@ void SplitLargeMeshesProcess_Vertex::SplitMesh(
                 }
 
                 // and copy the contents of the old array, offset by current base
-                for (unsigned int v = 0; v < iNumIndices;++v)
-                {
+                for (unsigned int v = 0; v < iNumIndices;++v) {
                     unsigned int iIndex = pMesh->mFaces[iBase].mIndices[v];
 
                     // check whether we do already have this vertex
-                    if (0xFFFFFFFF != avWasCopied[iIndex])
-                    {
+                    if (0xFFFFFFFF != avWasCopied[iIndex]) {
                         rFace.mIndices[v] = avWasCopied[iIndex];
                         continue;
                     }
@@ -559,49 +520,38 @@ void SplitLargeMeshesProcess_Vertex::SplitMesh(
                     pcMesh->mVertices[pcMesh->mNumVertices] = (pMesh->mVertices[iIndex]);
 
                     // copy normals
-                    if (pMesh->HasNormals())
-                    {
+                    if (pMesh->HasNormals()) {
                         pcMesh->mNormals[pcMesh->mNumVertices] = (pMesh->mNormals[iIndex]);
                     }
 
                     // copy tangents/bitangents
-                    if (pMesh->HasTangentsAndBitangents())
-                    {
+                    if (pMesh->HasTangentsAndBitangents()) {
                         pcMesh->mTangents[pcMesh->mNumVertices] = (pMesh->mTangents[iIndex]);
                         pcMesh->mBitangents[pcMesh->mNumVertices] = (pMesh->mBitangents[iIndex]);
                     }
 
                     // texture coordinates
-                    for (unsigned int c = 0;  c < AI_MAX_NUMBER_OF_TEXTURECOORDS;++c)
-                    {
-                        if (pMesh->HasTextureCoords( c))
-                        {
+                    for (unsigned int c = 0;  c < AI_MAX_NUMBER_OF_TEXTURECOORDS;++c) {
+                        if (pMesh->HasTextureCoords( c)) {
                             pcMesh->mTextureCoords[c][pcMesh->mNumVertices] = pMesh->mTextureCoords[c][iIndex];
                         }
                     }
                     // vertex colors
-                    for (unsigned int c = 0;  c < AI_MAX_NUMBER_OF_COLOR_SETS;++c)
-                    {
-                        if (pMesh->HasVertexColors( c))
-                        {
+                    for (unsigned int c = 0;  c < AI_MAX_NUMBER_OF_COLOR_SETS;++c) {
+                        if (pMesh->HasVertexColors( c)) {
                             pcMesh->mColors[c][pcMesh->mNumVertices] = pMesh->mColors[c][iIndex];
                         }
                     }
                     // check whether we have bone weights assigned to this vertex
                     rFace.mIndices[v] = pcMesh->mNumVertices;
-                    if (avPerVertexWeights)
-                    {
+                    if (avPerVertexWeights) {
                         VertexWeightTable& table = avPerVertexWeights[ pcMesh->mNumVertices ];
-                        if( !table.empty() )
-                        {
-                            for (VertexWeightTable::const_iterator
-                                iter =  table.begin();
-                                iter != table.end();++iter)
-                            {
+                        if( !table.empty() ) {
+                            for (VertexWeightTable::const_iterator iter =  table.begin();
+                                    iter != table.end();++iter) {
                                 // allocate the bone weight array if necessary
                                 BoneWeightList* pcWeightList = (BoneWeightList*)pcMesh->mBones[(*iter).first];
-                                if (!pcWeightList)
-                                {
+                                if (nullptr == pcWeightList) {
                                     pcMesh->mBones[(*iter).first] = (aiBone*)(pcWeightList = new BoneWeightList());
                                 }
                                 pcWeightList->push_back(aiVertexWeight(pcMesh->mNumVertices,(*iter).second));
@@ -612,26 +562,22 @@ void SplitLargeMeshesProcess_Vertex::SplitMesh(
                     avWasCopied[iIndex] = pcMesh->mNumVertices;
                     pcMesh->mNumVertices++;
                 }
-                iBase++;
-                if(pcMesh->mNumVertices == iOutVertexNum)
-                {
+                ++iBase;
+                if(pcMesh->mNumVertices == iOutVertexNum) {
                     // break here. The face is only added if it was complete
                     break;
                 }
             }
 
             // check which bones we'll need to create for this submesh
-            if (pMesh->HasBones())
-            {
+            if (pMesh->HasBones()) {
                 aiBone** ppCurrent = pcMesh->mBones;
-                for (unsigned int k = 0; k < pMesh->mNumBones;++k)
-                {
+                for (unsigned int k = 0; k < pMesh->mNumBones;++k) {
                     // check whether the bone is existing
                     BoneWeightList* pcWeightList;
-                    if ((pcWeightList = (BoneWeightList*)pcMesh->mBones[k]))
-                    {
+                    if ((pcWeightList = (BoneWeightList*)pcMesh->mBones[k])) {
                         aiBone* pcOldBone = pMesh->mBones[k];
-                        aiBone* pcOut;
+                        aiBone* pcOut( nullptr );
                         *ppCurrent++ = pcOut = new aiBone();
                         pcOut->mName = aiString(pcOldBone->mName);
                         pcOut->mOffsetMatrix = pcOldBone->mOffsetMatrix;
@@ -653,14 +599,14 @@ void SplitLargeMeshesProcess_Vertex::SplitMesh(
             pcMesh->mFaces = new aiFace[vFaces.size()];
             pcMesh->mNumFaces = (unsigned int)vFaces.size();
 
-            for (unsigned int p = 0; p < pcMesh->mNumFaces;++p)
+            for (unsigned int p = 0; p < pcMesh->mNumFaces;++p) {
                 pcMesh->mFaces[p] = vFaces[p];
+            }
 
             // add the newly created mesh to the list
             avList.push_back(std::pair<aiMesh*, unsigned int>(pcMesh,a));
 
-            if (iBase == pMesh->mNumFaces)
-            {
+            if (iBase == pMesh->mNumFaces) {
                 // have all faces ... finish the outer loop, too
                 break;
             }
@@ -674,5 +620,4 @@ void SplitLargeMeshesProcess_Vertex::SplitMesh(
         return;
     }
     avList.push_back(std::pair<aiMesh*, unsigned int>(pMesh,a));
-    return;
 }

code/TextureTransform.h

@@ -65,14 +65,14 @@ namespace Assimp    {
 /** Small helper structure representing a shortcut into the material list
  *  to be able to update some values quickly.
 */
-struct TTUpdateInfo
-{
-    TTUpdateInfo() :
-            directShortcut  (NULL)
-        ,   mat             (NULL)
-        ,   semantic        (0)
-        ,   index           (0)
-    {}
+struct TTUpdateInfo {
+    TTUpdateInfo() AI_NO_EXCEPT
+    : directShortcut(nullptr)
+    , mat(nullptr)
+    , semantic(0)
+    , index(0) {
+        // empty
+    }
 
     //! Direct shortcut, if available
     unsigned int* directShortcut;
@@ -88,15 +88,14 @@ struct TTUpdateInfo
 // ---------------------------------------------------------------------------
 /** Helper class representing texture coordinate transformations
 */
-struct STransformVecInfo : public aiUVTransform
-{
-
-    STransformVecInfo()
-        :   uvIndex     (0)
-        ,   mapU        (aiTextureMapMode_Wrap)
-        ,   mapV        (aiTextureMapMode_Wrap)
-        ,   lockedPos   (AI_TT_UV_IDX_LOCK_NONE)
-    {}
+struct STransformVecInfo : public aiUVTransform {
+    STransformVecInfo() AI_NO_EXCEPT
+    : uvIndex(0)
+    , mapU(aiTextureMapMode_Wrap)
+    , mapV(aiTextureMapMode_Wrap)
+    , lockedPos(AI_TT_UV_IDX_LOCK_NONE) {
+        // empty
+    }
 
     //! Source texture coordinate index
     unsigned int uvIndex;

code/ValidateDataStructure.cpp

@@ -491,8 +491,12 @@ void ValidateDSProcess::Validate( const aiMesh* pMesh)
             {
                 if (pMesh->mBones[i]->mName == pMesh->mBones[a]->mName)
                 {
-                    ReportError("aiMesh::mBones[%i] has the same name as "
-                        "aiMesh::mBones[%i]",i,a);
+                    const char *name = "unknown";
+                    if (nullptr != pMesh->mBones[ i ]->mName.C_Str()) {
+                        name = pMesh->mBones[ i ]->mName.C_Str();
+                    }
+                    ReportError("aiMesh::mBones[%i], name = \"%s\" has the same name as "
+                        "aiMesh::mBones[%i]", i, name, a );
                 }
             }
         }

code/XFileHelper.h

@@ -55,32 +55,33 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <assimp/anim.h>
 #include <assimp/Defines.h>
 
-namespace Assimp
-{
-namespace XFile
-{
+namespace Assimp {
+namespace XFile {
 
 /** Helper structure representing a XFile mesh face */
-struct Face
-{
+struct Face {
     std::vector<unsigned int> mIndices;
 };
 
 /** Helper structure representing a texture filename inside a material and its potential source */
-struct TexEntry
-{
+struct TexEntry {
     std::string mName;
     bool mIsNormalMap; // true if the texname was specified in a NormalmapFilename tag
 
-    TexEntry() { mIsNormalMap = false; }
-    TexEntry( const std::string& pName, bool pIsNormalMap = false)
-        : mName( pName), mIsNormalMap( pIsNormalMap)
-    { /* done */ }
+    TexEntry() AI_NO_EXCEPT
+    : mName()
+    , mIsNormalMap(false) {
+        // empty
+    }
+    TexEntry(const std::string& pName, bool pIsNormalMap = false)
+    : mName(pName)
+    , mIsNormalMap(pIsNormalMap) {
+        // empty
+    }
 };
 
 /** Helper structure representing a XFile material */
-struct Material
-{
+struct Material {
     std::string mName;
     bool mIsReference; // if true, mName holds a name by which the actual material can be found in the material list
     aiColor4D mDiffuse;
@@ -88,19 +89,18 @@ struct Material
     aiColor3D mSpecular;
     aiColor3D mEmissive;
     std::vector<TexEntry> mTextures;
-
     size_t sceneIndex; ///< the index under which it was stored in the scene's material list
 
-    Material()
-        : mIsReference(false),
-        mSpecularExponent(),
-        sceneIndex(SIZE_MAX)
-    {}
+    Material() AI_NO_EXCEPT
+    : mIsReference(false)
+    , mSpecularExponent()
+    , sceneIndex(SIZE_MAX) {
+        // empty
+    }
 };
 
 /** Helper structure to represent a bone weight */
-struct BoneWeight
-{
+struct BoneWeight {
     unsigned int mVertex;
     ai_real mWeight;
 };
@@ -114,8 +114,7 @@ struct Bone
 };
 
 /** Helper structure to represent an XFile mesh */
-struct Mesh
-{
+struct Mesh {
     std::string mName;
     std::vector<aiVector3D> mPositions;
     std::vector<Face> mPosFaces;
@@ -131,38 +130,65 @@ struct Mesh
 
     std::vector<Bone> mBones;
 
-    explicit Mesh(const std::string &pName = "") { mName = pName; mNumTextures = 0; mNumColorSets = 0; }
+    explicit Mesh(const std::string &pName = "") AI_NO_EXCEPT
+    : mName( pName )
+    , mPositions()
+    , mPosFaces()
+    , mNormals()
+    , mNormFaces()
+    , mNumTextures(0)
+    , mTexCoords{}
+    , mNumColorSets(0)
+    , mColors{}
+    , mFaceMaterials()
+    , mMaterials()
+    , mBones() {
+        // empty
+    }
 };
 
 /** Helper structure to represent a XFile frame */
-struct Node
-{
+struct Node {
     std::string mName;
     aiMatrix4x4 mTrafoMatrix;
     Node* mParent;
     std::vector<Node*> mChildren;
     std::vector<Mesh*> mMeshes;
 
-    Node() { mParent = NULL; }
-    explicit Node( Node* pParent) { mParent = pParent; }
-    ~Node()
-    {
-        for( unsigned int a = 0; a < mChildren.size(); a++)
+    Node() AI_NO_EXCEPT
+    : mName()
+    , mTrafoMatrix()
+    , mParent(nullptr)
+    , mChildren()
+    , mMeshes() {
+        // empty
+    }
+    explicit Node( Node* pParent)
+    : mName()
+    , mTrafoMatrix()
+    , mParent(pParent)
+    , mChildren()
+    , mMeshes() {
+        // empty
+    }
+
+    ~Node() {
+        for (unsigned int a = 0; a < mChildren.size(); ++a ) {
             delete mChildren[a];
-        for( unsigned int a = 0; a < mMeshes.size(); a++)
+        }
+        for (unsigned int a = 0; a < mMeshes.size(); ++a) {
             delete mMeshes[a];
+        }
     }
 };
 
-struct MatrixKey
-{
+struct MatrixKey {
     double mTime;
     aiMatrix4x4 mMatrix;
 };
 
 /** Helper structure representing a single animated bone in a XFile */
-struct AnimBone
-{
+struct AnimBone {
     std::string mBoneName;
     std::vector<aiVectorKey> mPosKeys;  // either three separate key sequences for position, rotation, scaling
     std::vector<aiQuatKey> mRotKeys;
@@ -194,14 +220,22 @@ struct Scene
     std::vector<Animation*> mAnims;
     unsigned int mAnimTicksPerSecond;
 
-    Scene() { mRootNode = NULL; mAnimTicksPerSecond = 0; }
-    ~Scene()
-    {
+    Scene() AI_NO_EXCEPT
+    : mRootNode(nullptr)
+    , mGlobalMeshes()
+    , mGlobalMaterials()
+    , mAnimTicksPerSecond(0) {
+        // empty
+    }
+    ~Scene() {
         delete mRootNode;
-        for( unsigned int a = 0; a < mGlobalMeshes.size(); a++)
+        mRootNode = nullptr;
+        for (unsigned int a = 0; a < mGlobalMeshes.size(); ++a ) {
             delete mGlobalMeshes[a];
-        for( unsigned int a = 0; a < mAnims.size(); a++)
+        }
+        for (unsigned int a = 0; a < mAnims.size(); ++a ) {
             delete mAnims[a];
+        }
     }
 };
 

code/glTF2Asset.h

@@ -170,7 +170,7 @@ namespace glTF2
 	#include <assimp/pbrmaterial.h>
 
     #ifdef ASSIMP_API
-        #include "./../include/assimp/Compiler/pushpack1.h"
+        #include <assimp/Compiler/pushpack1.h>
     #endif
 
     //! For binary .glb files
@@ -189,7 +189,7 @@ namespace glTF2
     } PACK_STRUCT;
 
     #ifdef ASSIMP_API
-        #include "./../include/assimp/Compiler/poppack1.h"
+        #include <assimp/Compiler/poppack1.h>
     #endif
 
 
@@ -303,6 +303,20 @@ namespace glTF2
         TextureType_UNSIGNED_SHORT_5_5_5_1 = 32820
     };
 
+    //! Values for the Animation::Target::path field
+    enum AnimationPath {
+        AnimationPath_TRANSLATION,
+        AnimationPath_ROTATION,
+        AnimationPath_SCALE,
+        AnimationPath_WEIGHTS,
+    };
+
+    //! Values for the Animation::Sampler::interpolation field
+    enum Interpolation {
+        Interpolation_LINEAR,
+        Interpolation_STEP,
+        Interpolation_CUBICSPLINE,
+    };
 
     //! Values for the Accessor::type field (helper class)
     class AttribType
@@ -659,7 +673,7 @@ namespace glTF2
         int width, height;
 
     private:
-        uint8_t* mData;
+        std::unique_ptr<uint8_t[]> mData;
         size_t mDataLength;
 
     public:
@@ -674,7 +688,7 @@ namespace glTF2
             { return mDataLength; }
 
         inline const uint8_t* GetData() const
-            { return mData; }
+            { return mData.get(); }
 
         inline uint8_t* StealData();
 
@@ -742,7 +756,7 @@ namespace glTF2
         //extension: KHR_materials_pbrSpecularGlossiness
         Nullable<PbrSpecularGlossiness> pbrSpecularGlossiness;
 
-        //extension: KHR_materials_unlit 
+        //extension: KHR_materials_unlit
         bool unlit;
 
         Material() { SetDefaults(); }
@@ -870,56 +884,35 @@ namespace glTF2
 
     struct Animation : public Object
     {
-        struct AnimSampler {
-            std::string id;               //!< The ID of this sampler.
-            std::string input;            //!< The ID of a parameter in this animation to use as key-frame input.
-            std::string interpolation;    //!< Type of interpolation algorithm to use between key-frames.
-            std::string output;           //!< The ID of a parameter in this animation to use as key-frame output.
+        struct Sampler {
+            Sampler() : interpolation(Interpolation_LINEAR) {}
+
+            Ref<Accessor> input;          //!< Accessor reference to the buffer storing the key-frame times.
+            Ref<Accessor> output;         //!< Accessor reference to the buffer storing the key-frame values.
+            Interpolation interpolation;  //!< Type of interpolation algorithm to use between key-frames.
         };
 
-        struct AnimChannel {
-            int sampler;                 //!< The index of a sampler in the containing animation's samplers property.
+        struct Target {
+            Target() : path(AnimationPath_TRANSLATION) {}
 
-            struct AnimTarget {
-                Ref<Node> node;          //!< The node to animate.
-                std::string path;        //!< The name of property of the node to animate ("translation", "rotation", or "scale").
-            } target;
+            Ref<Node> node;                //!< The node to animate.
+            AnimationPath path;            //!< The property of the node to animate.
         };
 
-        struct AnimParameters {
-            Ref<Accessor> TIME;           //!< Accessor reference to a buffer storing a array of floating point scalar values.
-            Ref<Accessor> rotation;       //!< Accessor reference to a buffer storing a array of four-component floating-point vectors.
-            Ref<Accessor> scale;          //!< Accessor reference to a buffer storing a array of three-component floating-point vectors.
-            Ref<Accessor> translation;    //!< Accessor reference to a buffer storing a array of three-component floating-point vectors.
-        };
+        struct Channel {
+            Channel() : sampler(-1) {}
 
-        // AnimChannel Channels[3];            //!< Connect the output values of the key-frame animation to a specific node in the hierarchy.
-        // AnimParameters Parameters;          //!< The samplers that interpolate between the key-frames.
-        // AnimSampler Samplers[3];            //!< The parameterized inputs representing the key-frame data.
+            int sampler;                   //!< The sampler index containing the animation data.
+            Target target;                 //!< The node and property to animate.
+        };
 
-        std::vector<AnimChannel> Channels;            //!< Connect the output values of the key-frame animation to a specific node in the hierarchy.
-        AnimParameters Parameters;                    //!< The samplers that interpolate between the key-frames.
-        std::vector<AnimSampler> Samplers;         //!< The parameterized inputs representing the key-frame data.
+        std::vector<Sampler> samplers;     //!< All the key-frame data for this animation.
+        std::vector<Channel> channels;     //!< Data to connect nodes to key-frames.
 
         Animation() {}
         void Read(Value& obj, Asset& r);
-
-        //! Get accessor given an animation parameter name.
-        Ref<Accessor> GetAccessor(std::string name) {
-            if (name == "TIME") {
-                return Parameters.TIME;
-            } else if (name == "rotation") {
-                return Parameters.rotation;
-            } else if (name == "scale") {
-                return Parameters.scale;
-            } else if (name == "translation") {
-                return Parameters.translation;
-            }
-            return Ref<Accessor>();
-        }
     };
 
-
     //! Base class for LazyDict that acts as an interface
     class LazyDictBase
     {

code/glTF2Asset.inl

@@ -461,7 +461,7 @@ inline void Buffer::EncodedRegion_SetCurrent(const std::string& pID)
 	throw DeadlyImportError("GLTF: EncodedRegion with ID: \"" + pID + "\" not found.");
 }
 
-inline 
+inline
 bool Buffer::ReplaceData(const size_t pBufferData_Offset, const size_t pBufferData_Count, const uint8_t* pReplace_Data, const size_t pReplace_Count)
 {
 
@@ -483,8 +483,8 @@ bool Buffer::ReplaceData(const size_t pBufferData_Offset, const size_t pBufferDa
 
 	return true;
 }
-	
-inline 
+
+inline
 bool Buffer::ReplaceData_joint(const size_t pBufferData_Offset, const size_t pBufferData_Count, const uint8_t* pReplace_Data, const size_t pReplace_Count)
 {
 	if((pBufferData_Count == 0) || (pReplace_Count == 0) || (pReplace_Data == nullptr)) {
@@ -688,7 +688,6 @@ T Accessor::Indexer::GetValue(int i)
 inline Image::Image()
     : width(0)
     , height(0)
-    , mData(0)
     , mDataLength(0)
 {
 
@@ -704,7 +703,9 @@ inline void Image::Read(Value& obj, Asset& r)
             if (ParseDataURI(uristr, uri->GetStringLength(), dataURI)) {
                 mimeType = dataURI.mediaType;
                 if (dataURI.base64) {
-                    mDataLength = Util::DecodeBase64(dataURI.data, dataURI.dataLength, mData);
+                    uint8_t *ptr = nullptr;
+                    mDataLength = Util::DecodeBase64(dataURI.data, dataURI.dataLength, ptr);
+                    mData.reset(ptr);
                 }
             }
             else {
@@ -717,8 +718,9 @@ inline void Image::Read(Value& obj, Asset& r)
 
             this->mDataLength = this->bufferView->byteLength;
             // maybe this memcpy could be avoided if aiTexture does not delete[] pcData at destruction.
-            this->mData = new uint8_t [this->mDataLength];
-            memcpy(this->mData, buffer->GetPointer() + this->bufferView->byteOffset, this->mDataLength);
+
+			this->mData.reset(new uint8_t[this->mDataLength]);
+			memcpy(this->mData.get(), buffer->GetPointer() + this->bufferView->byteOffset, this->mDataLength);
 
             if (Value* mtype = FindString(obj, "mimeType")) {
                 this->mimeType = mtype->GetString();
@@ -729,10 +731,8 @@ inline void Image::Read(Value& obj, Asset& r)
 
 inline uint8_t* Image::StealData()
 {
-    uint8_t* data = mData;
-    mDataLength = 0;
-    mData = 0;
-    return data;
+	mDataLength = 0;
+	return mData.release();
 }
 
 inline void Image::SetData(uint8_t* data, size_t length, Asset& r)
@@ -747,8 +747,8 @@ inline void Image::SetData(uint8_t* data, size_t length, Asset& r)
         bufferView->byteOffset = b->AppendData(data, length);
     }
     else { // text file: will be stored as a data uri
-        this->mData = data;
-        this->mDataLength = length;
+		this->mData.reset(data);
+		this->mDataLength = length;
     }
 }
 
@@ -1023,7 +1023,12 @@ inline void Mesh::Read(Value& pJSON_Object, Asset& pAsset_Root)
 
 inline void Camera::Read(Value& obj, Asset& /*r*/)
 {
-    type = MemberOrDefault(obj, "type", Camera::Perspective);
+    std::string type_string = std::string(MemberOrDefault(obj, "type", "perspective"));
+    if (type_string == "orthographic") {
+        type = Camera::Orthographic;
+    } else {
+        type = Camera::Perspective;
+    }
 
     const char* subobjId = (type == Camera::Orthographic) ? "orthographic" : "perspective";
 
@@ -1078,6 +1083,10 @@ inline void Node::Read(Value& obj, Asset& r)
         if (meshRef) this->meshes.push_back(meshRef);
     }
 
+    if (Value* skin = FindUInt(obj, "skin")) {
+        this->skin = r.skins.Retrieve(skin->GetUint());
+    }
+
     if (Value* camera = FindUInt(obj, "camera")) {
         this->camera = r.cameras.Retrieve(camera->GetUint());
         if (this->camera)
@@ -1097,6 +1106,82 @@ inline void Scene::Read(Value& obj, Asset& r)
     }
 }
 
+inline void Skin::Read(Value& obj, Asset& r)
+{
+    if (Value* matrices = FindUInt(obj, "inverseBindMatrices")) {
+        inverseBindMatrices = r.accessors.Retrieve(matrices->GetUint());
+    }
+
+    if (Value* joints = FindArray(obj, "joints")) {
+        for (unsigned i = 0; i < joints->Size(); ++i) {
+            if (!(*joints)[i].IsUint()) continue;
+            Ref<Node> node = r.nodes.Retrieve((*joints)[i].GetUint());
+            if (node) {
+                this->jointNames.push_back(node);
+            }
+        }
+    }
+}
+
+inline void Animation::Read(Value& obj, Asset& r)
+{
+    if (Value* samplers = FindArray(obj, "samplers")) {
+        for (unsigned i = 0; i < samplers->Size(); ++i) {
+            Value& sampler = (*samplers)[i];
+
+            Sampler s;
+            if (Value* input = FindUInt(sampler, "input")) {
+                s.input = r.accessors.Retrieve(input->GetUint());
+            }
+            if (Value* output = FindUInt(sampler, "output")) {
+                s.output = r.accessors.Retrieve(output->GetUint());
+            }
+            s.interpolation = Interpolation_LINEAR;
+            if (Value* interpolation = FindString(sampler, "interpolation")) {
+                const std::string interp = interpolation->GetString();
+                if (interp == "LINEAR") {
+                  s.interpolation = Interpolation_LINEAR;
+                } else if (interp == "STEP") {
+                  s.interpolation = Interpolation_STEP;
+                } else if (interp == "CUBICSPLINE") {
+                  s.interpolation = Interpolation_CUBICSPLINE;
+                }
+            }
+            this->samplers.push_back(s);
+        }
+    }
+
+    if (Value* channels = FindArray(obj, "channels")) {
+        for (unsigned i = 0; i < channels->Size(); ++i) {
+            Value& channel = (*channels)[i];
+
+            Channel c;
+            if (Value* sampler = FindUInt(channel, "sampler")) {
+                c.sampler = sampler->GetUint();
+            }
+
+            if (Value* target = FindObject(channel, "target")) {
+                if (Value* node = FindUInt(*target, "node")) {
+                    c.target.node = r.nodes.Retrieve(node->GetUint());
+                }
+                if (Value* path = FindString(*target, "path")) {
+                    const std::string p = path->GetString();
+                    if (p == "translation") {
+                        c.target.path = AnimationPath_TRANSLATION;
+                    } else if (p == "rotation") {
+                        c.target.path = AnimationPath_ROTATION;
+                    } else if (p == "scale") {
+                        c.target.path = AnimationPath_SCALE;
+                    } else if (p == "weights") {
+                        c.target.path = AnimationPath_WEIGHTS;
+                    }
+                }
+            }
+            this->channels.push_back(c);
+        }
+    }
+}
+
 inline void AssetMetadata::Read(Document& doc)
 {
     if (Value* obj = FindObject(doc, "asset")) {
@@ -1272,6 +1357,19 @@ inline void Asset::Load(const std::string& pFile, bool isBinary)
         }
     }
 
+    // Force reading of skins since they're not always directly referenced
+    if (Value* skinsArray = FindArray(doc, "skins")) {
+        for (unsigned int i = 0; i < skinsArray->Size(); ++i) {
+            skins.Retrieve(i);
+        }
+    }
+
+    if (Value* animsArray = FindArray(doc, "animations")) {
+        for (unsigned int i = 0; i < animsArray->Size(); ++i) {
+            animations.Retrieve(i);
+        }
+    }
+
     // Clean up
     for (size_t i = 0; i < mDicts.size(); ++i) {
         mDicts[i]->DetachFromDocument();

code/glTF2AssetWriter.inl

@@ -113,10 +113,10 @@ namespace glTF2 {
         /****************** Channels *******************/
         Value channels;
         channels.SetArray();
-        channels.Reserve(unsigned(a.Channels.size()), w.mAl);
+        channels.Reserve(unsigned(a.channels.size()), w.mAl);
 
-        for (size_t i = 0; i < unsigned(a.Channels.size()); ++i) {
-            Animation::AnimChannel& c = a.Channels[i];
+        for (size_t i = 0; i < unsigned(a.channels.size()); ++i) {
+            Animation::Channel& c = a.channels[i];
             Value valChannel;
             valChannel.SetObject();
             {
@@ -126,7 +126,20 @@ namespace glTF2 {
                 valTarget.SetObject();
                 {
                     valTarget.AddMember("node", c.target.node->index, w.mAl);
-                    valTarget.AddMember("path", c.target.path, w.mAl);
+                    switch (c.target.path) {
+                        case AnimationPath_TRANSLATION:
+                            valTarget.AddMember("path", "translation", w.mAl);
+                            break;
+                        case AnimationPath_ROTATION:
+                            valTarget.AddMember("path", "rotation", w.mAl);
+                            break;
+                        case AnimationPath_SCALE:
+                            valTarget.AddMember("path", "scale", w.mAl);
+                            break;
+                        case AnimationPath_WEIGHTS:
+                            valTarget.AddMember("path", "weights", w.mAl);
+                            break;
+                    }
                 }
                 valChannel.AddMember("target", valTarget, w.mAl);
             }
@@ -138,16 +151,24 @@ namespace glTF2 {
         Value valSamplers;
         valSamplers.SetArray();
 
-        for (size_t i = 0; i < unsigned(a.Samplers.size()); ++i) {
-            Animation::AnimSampler& s = a.Samplers[i];
+        for (size_t i = 0; i < unsigned(a.samplers.size()); ++i) {
+            Animation::Sampler& s = a.samplers[i];
             Value valSampler;
             valSampler.SetObject();
             {
-                Ref<Accessor> inputAccessor = a.GetAccessor(s.input);
-                Ref<Accessor> outputAccessor = a.GetAccessor(s.output);
-                valSampler.AddMember("input", inputAccessor->index, w.mAl);
-                valSampler.AddMember("interpolation", s.interpolation, w.mAl);
-                valSampler.AddMember("output", outputAccessor->index, w.mAl);
+                valSampler.AddMember("input", s.input->index, w.mAl);
+                switch (s.interpolation) {
+                    case Interpolation_LINEAR:
+                        valSampler.AddMember("path", "LINEAR", w.mAl);
+                        break;
+                    case Interpolation_STEP:
+                        valSampler.AddMember("path", "STEP", w.mAl);
+                        break;
+                    case Interpolation_CUBICSPLINE:
+                        valSampler.AddMember("path", "CUBICSPLINE", w.mAl);
+                        break;
+                }
+                valSampler.AddMember("output", s.output->index, w.mAl);
             }
             valSamplers.PushBack(valSampler, w.mAl);
         }

code/glTF2Exporter.cpp

@@ -641,7 +641,7 @@ void ExportSkin(Asset& mAsset, const aiMesh* aimesh, Ref<Mesh>& meshRef, Ref<Buf
         unsigned int bytesPerComp = ComponentTypeSize(vertexJointAccessor->componentType);
         size_t s_bytesLen = bytesLen * s_bytesPerComp / bytesPerComp;
         Ref<Buffer> buf = vertexJointAccessor->bufferView->buffer;
-        uint8_t* arrys = new uint8_t[s_bytesLen];
+        uint8_t* arrys = new uint8_t[bytesLen];
         unsigned int i = 0;
         for ( unsigned int j = 0; j <= bytesLen; j += bytesPerComp ){
             size_t len_p = offset + j;
@@ -652,8 +652,9 @@ void ExportSkin(Asset& mAsset, const aiMesh* aimesh, Ref<Mesh>& meshRef, Ref<Buf
             memcpy(&arrys[i*s_bytesPerComp], data, s_bytesPerComp);
             ++i;
         }
-        buf->ReplaceData_joint(offset, bytesLen, arrys, s_bytesLen);
+        buf->ReplaceData_joint(offset, bytesLen, arrys, bytesLen);
         vertexJointAccessor->componentType = ComponentType_UNSIGNED_SHORT;
+        vertexJointAccessor->bufferView->byteLength = s_bytesLen;
 
         p.attributes.joint.push_back( vertexJointAccessor );
     }
@@ -960,92 +961,89 @@ void glTF2Exporter::ExportMetadata()
     asset.generator = buffer;
 }
 
-inline void ExtractAnimationData(Asset& mAsset, std::string& animId, Ref<Animation>& animRef, Ref<Buffer>& buffer, const aiNodeAnim* nodeChannel, float ticksPerSecond)
+inline Ref<Accessor> GetSamplerInputRef(Asset& asset, std::string& animId, Ref<Buffer>& buffer, std::vector<float>& times)
 {
-    // Loop over the data and check to see if it exactly matches an existing buffer.
-    //    If yes, then reference the existing corresponding accessor.
-    //    Otherwise, add to the buffer and create a new accessor.
-
-    size_t counts[3] = {
-        nodeChannel->mNumPositionKeys,
-        nodeChannel->mNumScalingKeys,
-        nodeChannel->mNumRotationKeys,
-    };
-    size_t numKeyframes = 1;
-    for (int i = 0; i < 3; ++i) {
-        if (counts[i] > numKeyframes) {
-            numKeyframes = counts[i];
-        }
-    }
+    return ExportData(asset, animId, buffer, times.size(), &times[0], AttribType::SCALAR, AttribType::SCALAR, ComponentType_FLOAT);
+}
 
-    //-------------------------------------------------------
-    // Extract TIME parameter data.
-    // Check if the timeStamps are the same for mPositionKeys, mRotationKeys, and mScalingKeys.
-    if(nodeChannel->mNumPositionKeys > 0) {
-        typedef float TimeType;
-        std::vector<TimeType> timeData;
-        timeData.resize(numKeyframes);
-        for (size_t i = 0; i < numKeyframes; ++i) {
-            size_t frameIndex = i * nodeChannel->mNumPositionKeys / numKeyframes;
-            // mTime is measured in ticks, but GLTF time is measured in seconds, so convert.
-            // Check if we have to cast type here. e.g. uint16_t()
-            timeData[i] = static_cast<float>(nodeChannel->mPositionKeys[frameIndex].mTime / ticksPerSecond);
-        }
+inline void ExtractTranslationSampler(Asset& asset, std::string& animId, Ref<Buffer>& buffer, const aiNodeAnim* nodeChannel, float ticksPerSecond, Animation::Sampler& sampler)
+{
+    const unsigned int numKeyframes = nodeChannel->mNumPositionKeys;
+    if (numKeyframes == 0) {
+        return;
+    }
 
-        Ref<Accessor> timeAccessor = ExportData(mAsset, animId, buffer, static_cast<unsigned int>(numKeyframes), &timeData[0], AttribType::SCALAR, AttribType::SCALAR, ComponentType_FLOAT);
-        if (timeAccessor) animRef->Parameters.TIME = timeAccessor;
+    std::vector<float> times(numKeyframes);
+    std::vector<float> values(numKeyframes * 3);
+    for (unsigned int i = 0; i < numKeyframes; ++i) {
+        const aiVectorKey& key = nodeChannel->mPositionKeys[i];
+        // mTime is measured in ticks, but GLTF time is measured in seconds, so convert.
+        times[i] = static_cast<float>(key.mTime / ticksPerSecond);
+        values[(i * 3) + 0] = key.mValue.x;
+        values[(i * 3) + 1] = key.mValue.y;
+        values[(i * 3) + 2] = key.mValue.z;
     }
 
-    //-------------------------------------------------------
-    // Extract translation parameter data
-    if(nodeChannel->mNumPositionKeys > 0) {
-        C_STRUCT aiVector3D* translationData = new aiVector3D[numKeyframes];
-        for (size_t i = 0; i < numKeyframes; ++i) {
-            size_t frameIndex = i * nodeChannel->mNumPositionKeys / numKeyframes;
-            translationData[i] = nodeChannel->mPositionKeys[frameIndex].mValue;
-        }
+    sampler.input = GetSamplerInputRef(asset, animId, buffer, times);
+    sampler.output = ExportData(asset, animId, buffer, numKeyframes, &values[0], AttribType::VEC3, AttribType::VEC3, ComponentType_FLOAT);
+    sampler.interpolation = Interpolation_LINEAR;
+}
 
-        Ref<Accessor> tranAccessor = ExportData(mAsset, animId, buffer, static_cast<unsigned int>(numKeyframes), translationData, AttribType::VEC3, AttribType::VEC3, ComponentType_FLOAT);
-        if ( tranAccessor ) {
-            animRef->Parameters.translation = tranAccessor;
-        }
-        delete[] translationData;
+inline void ExtractScaleSampler(Asset& asset, std::string& animId, Ref<Buffer>& buffer, const aiNodeAnim* nodeChannel, float ticksPerSecond, Animation::Sampler& sampler)
+{
+    const unsigned int numKeyframes = nodeChannel->mNumScalingKeys;
+    if (numKeyframes == 0) {
+        return;
     }
 
-    //-------------------------------------------------------
-    // Extract scale parameter data
-    if(nodeChannel->mNumScalingKeys > 0) {
-        C_STRUCT aiVector3D* scaleData = new aiVector3D[numKeyframes];
-        for (size_t i = 0; i < numKeyframes; ++i) {
-            size_t frameIndex = i * nodeChannel->mNumScalingKeys / numKeyframes;
-            scaleData[i] = nodeChannel->mScalingKeys[frameIndex].mValue;
-        }
-
-        Ref<Accessor> scaleAccessor = ExportData(mAsset, animId, buffer, static_cast<unsigned int>(numKeyframes), scaleData, AttribType::VEC3, AttribType::VEC3, ComponentType_FLOAT);
-        if ( scaleAccessor ) {
-            animRef->Parameters.scale = scaleAccessor;
-        }
-        delete[] scaleData;
+    std::vector<float> times(numKeyframes);
+    std::vector<float> values(numKeyframes * 3);
+    for (unsigned int i = 0; i < numKeyframes; ++i) {
+        const aiVectorKey& key = nodeChannel->mScalingKeys[i];
+        // mTime is measured in ticks, but GLTF time is measured in seconds, so convert.
+        times[i] = static_cast<float>(key.mTime / ticksPerSecond);
+        values[(i * 3) + 0] = key.mValue.x;
+        values[(i * 3) + 1] = key.mValue.y;
+        values[(i * 3) + 2] = key.mValue.z;
     }
 
-    //-------------------------------------------------------
-    // Extract rotation parameter data
-    if(nodeChannel->mNumRotationKeys > 0) {
-        vec4* rotationData = new vec4[numKeyframes];
-        for (size_t i = 0; i < numKeyframes; ++i) {
-            size_t frameIndex = i * nodeChannel->mNumRotationKeys / numKeyframes;
-            rotationData[i][0] = nodeChannel->mRotationKeys[frameIndex].mValue.x;
-            rotationData[i][1] = nodeChannel->mRotationKeys[frameIndex].mValue.y;
-            rotationData[i][2] = nodeChannel->mRotationKeys[frameIndex].mValue.z;
-            rotationData[i][3] = nodeChannel->mRotationKeys[frameIndex].mValue.w;
-        }
+    sampler.input = GetSamplerInputRef(asset, animId, buffer, times);
+    sampler.output = ExportData(asset, animId, buffer, numKeyframes, &values[0], AttribType::VEC3, AttribType::VEC3, ComponentType_FLOAT);
+    sampler.interpolation = Interpolation_LINEAR;
+}
 
-        Ref<Accessor> rotAccessor = ExportData(mAsset, animId, buffer, static_cast<unsigned int>(numKeyframes), rotationData, AttribType::VEC4, AttribType::VEC4, ComponentType_FLOAT);
-        if ( rotAccessor ) {
-            animRef->Parameters.rotation = rotAccessor;
-        }
-        delete[] rotationData;
+inline void ExtractRotationSampler(Asset& asset, std::string& animId, Ref<Buffer>& buffer, const aiNodeAnim* nodeChannel, float ticksPerSecond, Animation::Sampler& sampler)
+{
+    const unsigned int numKeyframes = nodeChannel->mNumRotationKeys;
+    if (numKeyframes == 0) {
+        return;
     }
+
+    std::vector<float> times(numKeyframes);
+    std::vector<float> values(numKeyframes * 4);
+    for (unsigned int i = 0; i < numKeyframes; ++i) {
+        const aiQuatKey& key = nodeChannel->mRotationKeys[i];
+        // mTime is measured in ticks, but GLTF time is measured in seconds, so convert.
+        times[i] = static_cast<float>(key.mTime / ticksPerSecond);
+        values[(i * 4) + 0] = key.mValue.x;
+        values[(i * 4) + 1] = key.mValue.y;
+        values[(i * 4) + 2] = key.mValue.z;
+        values[(i * 4) + 3] = key.mValue.w;
+    }
+
+    sampler.input = GetSamplerInputRef(asset, animId, buffer, times);
+    sampler.output = ExportData(asset, animId, buffer, numKeyframes, &values[0], AttribType::VEC4, AttribType::VEC4, ComponentType_FLOAT);
+    sampler.interpolation = Interpolation_LINEAR;
+}
+
+static void AddSampler(Ref<Animation>& animRef, Ref<Node>& nodeRef, Animation::Sampler& sampler, AnimationPath path)
+{
+      Animation::Channel channel;
+      channel.sampler = static_cast<int>(animRef->samplers.size());
+      channel.target.path = path;
+      channel.target.node = nodeRef;
+      animRef->channels.push_back(channel);
+      animRef->samplers.push_back(sampler);
 }
 
 void glTF2Exporter::ExportAnimations()
@@ -1054,6 +1052,7 @@ void glTF2Exporter::ExportAnimations()
 
     for (unsigned int i = 0; i < mScene->mNumAnimations; ++i) {
         const aiAnimation* anim = mScene->mAnimations[i];
+        const float ticksPerSecond = static_cast<float>(anim->mTicksPerSecond);
 
         std::string nameAnim = "anim";
         if (anim->mName.length > 0) {
@@ -1069,46 +1068,19 @@ void glTF2Exporter::ExportAnimations()
             name = mAsset->FindUniqueID(name, "animation");
             Ref<Animation> animRef = mAsset->animations.Create(name);
 
-            // Parameters
-            ExtractAnimationData(*mAsset, name, animRef, bufferRef, nodeChannel, static_cast<float>(anim->mTicksPerSecond));
-
-            for (unsigned int j = 0; j < 3; ++j) {
-                std::string channelType;
-                int channelSize;
-                switch (j) {
-                    case 0:
-                        channelType = "rotation";
-                        channelSize = nodeChannel->mNumRotationKeys;
-                        break;
-                    case 1:
-                        channelType = "scale";
-                        channelSize = nodeChannel->mNumScalingKeys;
-                        break;
-                    case 2:
-                        channelType = "translation";
-                        channelSize = nodeChannel->mNumPositionKeys;
-                        break;
-                }
-
-                if (channelSize < 1) { continue; }
+            Ref<Node> animNode = mAsset->nodes.Get(nodeChannel->mNodeName.C_Str());
 
-                Animation::AnimChannel tmpAnimChannel;
-                Animation::AnimSampler tmpAnimSampler;
+            Animation::Sampler translationSampler;
+            ExtractTranslationSampler(*mAsset, name, bufferRef, nodeChannel, ticksPerSecond, translationSampler);
+            AddSampler(animRef, animNode, translationSampler, AnimationPath_TRANSLATION);
 
-                tmpAnimChannel.sampler = static_cast<int>(animRef->Samplers.size());
-                tmpAnimChannel.target.path = channelType;
-                tmpAnimSampler.output = channelType;
-                tmpAnimSampler.id = name + "_" + channelType;
-
-                tmpAnimChannel.target.node = mAsset->nodes.Get(nodeChannel->mNodeName.C_Str());
-
-                tmpAnimSampler.input = "TIME";
-                tmpAnimSampler.interpolation = "LINEAR";
-
-                animRef->Channels.push_back(tmpAnimChannel);
-                animRef->Samplers.push_back(tmpAnimSampler);
-            }
+            Animation::Sampler rotationSampler;
+            ExtractRotationSampler(*mAsset, name, bufferRef, nodeChannel, ticksPerSecond, rotationSampler);
+            AddSampler(animRef, animNode, rotationSampler, AnimationPath_ROTATION);
 
+            Animation::Sampler scaleSampler;
+            ExtractScaleSampler(*mAsset, name, bufferRef, nodeChannel, ticksPerSecond, scaleSampler);
+            AddSampler(animRef, animNode, scaleSampler, AnimationPath_SCALE);
         }
 
         // Assimp documentation staes this is not used (not implemented)

code/glTF2Importer.cpp

@@ -54,6 +54,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <assimp/CreateAnimMesh.h>
 
 #include <memory>
+#include <unordered_map>
 
 #include "MakeVerboseFormat.h"
 
@@ -272,7 +273,8 @@ static aiMaterial* ImportMaterial(std::vector<int>& embeddedTexIdxs, Asset& r, M
     aimat->AddProperty(&mat.pbrMetallicRoughness.metallicFactor, 1, AI_MATKEY_GLTF_PBRMETALLICROUGHNESS_METALLIC_FACTOR);
     aimat->AddProperty(&mat.pbrMetallicRoughness.roughnessFactor, 1, AI_MATKEY_GLTF_PBRMETALLICROUGHNESS_ROUGHNESS_FACTOR);
 
-    float roughnessAsShininess = (1 - mat.pbrMetallicRoughness.roughnessFactor) * 1000;
+    float roughnessAsShininess = 1 - mat.pbrMetallicRoughness.roughnessFactor;
+    roughnessAsShininess *= roughnessAsShininess * 1000;
     aimat->AddProperty(&roughnessAsShininess, 1, AI_MATKEY_SHININESS);
 
     SetMaterialTextureProperty(embeddedTexIdxs, r, mat.normalTexture, aimat, aiTextureType_NORMALS);
@@ -454,7 +456,7 @@ void glTF2Importer::ImportMeshes(glTF2::Asset& r)
 
             std::vector<Mesh::Primitive::Target>& targets = prim.targets;
             if (targets.size() > 0) {
-                aim->mNumAnimMeshes = targets.size();
+                aim->mNumAnimMeshes = (unsigned int)targets.size();
                 aim->mAnimMeshes = new aiAnimMesh*[aim->mNumAnimMeshes];
                 for (size_t i = 0; i < targets.size(); i++) {
                     aim->mAnimMeshes[i] = aiCreateAnimMesh(aim);
@@ -579,7 +581,7 @@ void glTF2Importer::ImportMeshes(glTF2::Asset& r)
             }
             else { // no indices provided so directly generate from counts
 
-                // use the already determined count as it includes checks 
+                // use the already determined count as it includes checks
                 unsigned int count = aim->mNumVertices;
 
                 switch (prim.mode) {
@@ -701,26 +703,7 @@ void glTF2Importer::ImportCameras(glTF2::Asset& r)
     }
 }
 
-aiNode* ImportNode(aiScene* pScene, glTF2::Asset& r, std::vector<unsigned int>& meshOffsets, glTF2::Ref<glTF2::Node>& ptr)
-{
-    Node& node = *ptr;
-
-    std::string nameOrId = node.name.empty() ? node.id : node.name;
-
-    aiNode* ainode = new aiNode(nameOrId);
-
-    if (!node.children.empty()) {
-        ainode->mNumChildren = unsigned(node.children.size());
-        ainode->mChildren = new aiNode*[ainode->mNumChildren];
-
-        for (unsigned int i = 0; i < ainode->mNumChildren; ++i) {
-            aiNode* child = ImportNode(pScene, r, meshOffsets, node.children[i]);
-            child->mParent = ainode;
-            ainode->mChildren[i] = child;
-        }
-    }
-
-    aiMatrix4x4& matrix = ainode->mTransformation;
+static void GetNodeTransform(aiMatrix4x4& matrix, const glTF2::Node& node) {
     if (node.matrix.isPresent) {
         CopyValue(node.matrix.value, matrix);
     }
@@ -747,24 +730,121 @@ aiNode* ImportNode(aiScene* pScene, glTF2::Asset& r, std::vector<unsigned int>&
             matrix = matrix * s;
         }
     }
+}
 
-    if (!node.meshes.empty()) {
-        int count = 0;
-        for (size_t i = 0; i < node.meshes.size(); ++i) {
-            int idx = node.meshes[i].GetIndex();
-            count += meshOffsets[idx + 1] - meshOffsets[idx];
+static void BuildVertexWeightMapping(Mesh::Primitive& primitive, std::vector<std::vector<aiVertexWeight>>& map)
+{
+    Mesh::Primitive::Attributes& attr = primitive.attributes;
+    if (attr.weight.empty() || attr.joint.empty()) {
+        return;
+    }
+    if (attr.weight[0]->count != attr.joint[0]->count) {
+        return;
+    }
+
+    const int num_vertices = attr.weight[0]->count;
+
+    struct Weights { float values[4]; };
+    Weights* weights = nullptr;
+    attr.weight[0]->ExtractData(weights);
+
+    struct Indices8 { uint8_t values[4]; };
+    struct Indices16 { uint16_t values[4]; };
+    Indices8* indices8 = nullptr;
+    Indices16* indices16 = nullptr;
+    if (attr.joint[0]->GetElementSize() == 4) {
+        attr.joint[0]->ExtractData(indices8);
+    }else {
+        attr.joint[0]->ExtractData(indices16);
+    }
+
+    for (int i = 0; i < num_vertices; ++i) {
+        for (int j = 0; j < 4; ++j) {
+            const unsigned int bone = (indices8!=nullptr) ? indices8[i].values[j] : indices16[i].values[j];
+            const float weight = weights[i].values[j];
+            if (weight > 0 && bone < map.size()) {
+                map[bone].reserve(8);
+                map[bone].emplace_back(i, weight);
+            }
         }
-        ainode->mNumMeshes = count;
+    }
+
+    delete[] weights;
+    delete[] indices8;
+    delete[] indices16;
+}
+
+aiNode* ImportNode(aiScene* pScene, glTF2::Asset& r, std::vector<unsigned int>& meshOffsets, glTF2::Ref<glTF2::Node>& ptr)
+{
+    Node& node = *ptr;
+
+    std::string nameOrId = node.name.empty() ? node.id : node.name;
+
+    aiNode* ainode = new aiNode(nameOrId);
+
+    if (!node.children.empty()) {
+        ainode->mNumChildren = unsigned(node.children.size());
+        ainode->mChildren = new aiNode*[ainode->mNumChildren];
+
+        for (unsigned int i = 0; i < ainode->mNumChildren; ++i) {
+            aiNode* child = ImportNode(pScene, r, meshOffsets, node.children[i]);
+            child->mParent = ainode;
+            ainode->mChildren[i] = child;
+        }
+    }
+
+    GetNodeTransform(ainode->mTransformation, node);
 
+    if (!node.meshes.empty()) {
+        // GLTF files contain at most 1 mesh per node.
+        assert(node.meshes.size() == 1);
+        int mesh_idx = node.meshes[0].GetIndex();
+        int count = meshOffsets[mesh_idx + 1] - meshOffsets[mesh_idx];
+
+        ainode->mNumMeshes = count;
         ainode->mMeshes = new unsigned int[count];
 
-        int k = 0;
-        for (size_t i = 0; i < node.meshes.size(); ++i) {
-            int idx = node.meshes[i].GetIndex();
-            for (unsigned int j = meshOffsets[idx]; j < meshOffsets[idx + 1]; ++j, ++k) {
-                ainode->mMeshes[k] = j;
+        if (node.skin) {
+            for (int primitiveNo = 0; primitiveNo < count; ++primitiveNo) {
+                aiMesh* mesh = pScene->mMeshes[meshOffsets[mesh_idx]+primitiveNo];
+                mesh->mNumBones = node.skin->jointNames.size();
+                mesh->mBones = new aiBone*[mesh->mNumBones];
+
+                // GLTF and Assimp choose to store bone weights differently.
+                // GLTF has each vertex specify which bones influence the vertex.
+                // Assimp has each bone specify which vertices it has influence over.
+                // To convert this data, we first read over the vertex data and pull
+                // out the bone-to-vertex mapping.  Then, when creating the aiBones,
+                // we copy the bone-to-vertex mapping into the bone.  This is unfortunate
+                // both because it's somewhat slow and because, for many applications,
+                // we then need to reconvert the data back into the vertex-to-bone
+                // mapping which makes things doubly-slow.
+                std::vector<std::vector<aiVertexWeight>> weighting(mesh->mNumBones);
+                BuildVertexWeightMapping(node.meshes[0]->primitives[primitiveNo], weighting);
+
+                for (size_t i = 0; i < mesh->mNumBones; ++i) {
+                    aiBone* bone = new aiBone();
+
+                    Ref<Node> joint = node.skin->jointNames[i];
+                    bone->mName = joint->name;
+                    GetNodeTransform(bone->mOffsetMatrix, *joint);
+
+                    std::vector<aiVertexWeight>& weights = weighting[i];
+
+                    bone->mNumWeights = weights.size();
+                    if (bone->mNumWeights > 0) {
+                        bone->mWeights = new aiVertexWeight[bone->mNumWeights];
+                        memcpy(bone->mWeights, weights.data(), bone->mNumWeights * sizeof(aiVertexWeight));
+                    }
+                    mesh->mBones[i] = bone;
+                }
             }
         }
+
+        int k = 0;
+        for (unsigned int j = meshOffsets[mesh_idx]; j < meshOffsets[mesh_idx + 1]; ++j, ++k) {
+            ainode->mMeshes[k] = j;
+        }
     }
 
     if (node.camera) {
@@ -801,6 +881,177 @@ void glTF2Importer::ImportNodes(glTF2::Asset& r)
     //}
 }
 
+struct AnimationSamplers {
+    AnimationSamplers() : translation(nullptr), rotation(nullptr), scale(nullptr) {}
+
+    Animation::Sampler* translation;
+    Animation::Sampler* rotation;
+    Animation::Sampler* scale;
+};
+
+aiNodeAnim* CreateNodeAnim(glTF2::Asset& r, Node& node, AnimationSamplers& samplers)
+{
+    aiNodeAnim* anim = new aiNodeAnim();
+    anim->mNodeName = node.name;
+
+    static const float kMillisecondsFromSeconds = 1000.f;
+
+    if (samplers.translation) {
+        float* times = nullptr;
+        samplers.translation->input->ExtractData(times);
+        aiVector3D* values = nullptr;
+        samplers.translation->output->ExtractData(values);
+        anim->mNumPositionKeys = samplers.translation->input->count;
+        anim->mPositionKeys = new aiVectorKey[anim->mNumPositionKeys];
+        for (unsigned int i = 0; i < anim->mNumPositionKeys; ++i) {
+            anim->mPositionKeys[i].mTime = times[i] * kMillisecondsFromSeconds;
+            anim->mPositionKeys[i].mValue = values[i];
+        }
+        delete[] times;
+        delete[] values;
+    } else if (node.translation.isPresent) {
+        anim->mNumPositionKeys = 1;
+        anim->mPositionKeys = new aiVectorKey();
+        anim->mPositionKeys->mTime = 0.f;
+        anim->mPositionKeys->mValue.x = node.translation.value[0];
+        anim->mPositionKeys->mValue.y = node.translation.value[1];
+        anim->mPositionKeys->mValue.z = node.translation.value[2];
+    }
+
+    if (samplers.rotation) {
+        float* times = nullptr;
+        samplers.rotation->input->ExtractData(times);
+        aiQuaternion* values = nullptr;
+        samplers.rotation->output->ExtractData(values);
+        anim->mNumRotationKeys = samplers.rotation->input->count;
+        anim->mRotationKeys = new aiQuatKey[anim->mNumRotationKeys];
+        for (unsigned int i = 0; i < anim->mNumRotationKeys; ++i) {
+            anim->mRotationKeys[i].mTime = times[i] * kMillisecondsFromSeconds;
+            anim->mRotationKeys[i].mValue.x = values[i].w;
+            anim->mRotationKeys[i].mValue.y = values[i].x;
+            anim->mRotationKeys[i].mValue.z = values[i].y;
+            anim->mRotationKeys[i].mValue.w = values[i].z;
+        }
+        delete[] times;
+        delete[] values;
+    } else if (node.rotation.isPresent) {
+        anim->mNumRotationKeys = 1;
+        anim->mRotationKeys = new aiQuatKey();
+        anim->mRotationKeys->mTime = 0.f;
+        anim->mRotationKeys->mValue.x = node.rotation.value[0];
+        anim->mRotationKeys->mValue.y = node.rotation.value[1];
+        anim->mRotationKeys->mValue.z = node.rotation.value[2];
+        anim->mRotationKeys->mValue.w = node.rotation.value[3];
+    }
+
+    if (samplers.scale) {
+        float* times = nullptr;
+        samplers.scale->input->ExtractData(times);
+        aiVector3D* values = nullptr;
+        samplers.scale->output->ExtractData(values);
+        anim->mNumScalingKeys = samplers.scale->input->count;
+        anim->mScalingKeys = new aiVectorKey[anim->mNumScalingKeys];
+        for (unsigned int i = 0; i < anim->mNumScalingKeys; ++i) {
+            anim->mScalingKeys[i].mTime = times[i] * kMillisecondsFromSeconds;
+            anim->mScalingKeys[i].mValue = values[i];
+        }
+        delete[] times;
+        delete[] values;
+    } else if (node.scale.isPresent) {
+        anim->mNumScalingKeys = 1;
+        anim->mScalingKeys = new aiVectorKey();
+        anim->mScalingKeys->mTime = 0.f;
+        anim->mScalingKeys->mValue.x = node.scale.value[0];
+        anim->mScalingKeys->mValue.y = node.scale.value[1];
+        anim->mScalingKeys->mValue.z = node.scale.value[2];
+    }
+
+    return anim;
+}
+
+std::unordered_map<unsigned int, AnimationSamplers> GatherSamplers(Animation& anim)
+{
+    std::unordered_map<unsigned int, AnimationSamplers> samplers;
+    for (unsigned int c = 0; c < anim.channels.size(); ++c) {
+        Animation::Channel& channel = anim.channels[c];
+        if (channel.sampler >= static_cast<int>(anim.samplers.size())) {
+            continue;
+        }
+
+        const unsigned int node_index = channel.target.node.GetIndex();
+
+        AnimationSamplers& sampler = samplers[node_index];
+        if (channel.target.path == AnimationPath_TRANSLATION) {
+            sampler.translation = &anim.samplers[channel.sampler];
+        } else if (channel.target.path == AnimationPath_ROTATION) {
+            sampler.rotation = &anim.samplers[channel.sampler];
+        } else if (channel.target.path == AnimationPath_SCALE) {
+            sampler.scale = &anim.samplers[channel.sampler];
+        }
+    }
+
+    return samplers;
+}
+
+void glTF2Importer::ImportAnimations(glTF2::Asset& r)
+{
+    if (!r.scene) return;
+
+    mScene->mNumAnimations = r.animations.Size();
+    if (mScene->mNumAnimations == 0) {
+        return;
+    }
+
+    mScene->mAnimations = new aiAnimation*[mScene->mNumAnimations];
+    for (unsigned int i = 0; i < r.animations.Size(); ++i) {
+        Animation& anim = r.animations[i];
+
+        aiAnimation* ai_anim = new aiAnimation();
+        ai_anim->mName = anim.name;
+        ai_anim->mDuration = 0;
+        ai_anim->mTicksPerSecond = 0;
+
+        std::unordered_map<unsigned int, AnimationSamplers> samplers = GatherSamplers(anim);
+
+        ai_anim->mNumChannels = r.skins[0].jointNames.size();
+        if (ai_anim->mNumChannels > 0) {
+            ai_anim->mChannels = new aiNodeAnim*[ai_anim->mNumChannels];
+            int j = 0;
+            for (auto& iter : r.skins[0].jointNames) {
+                ai_anim->mChannels[j] = CreateNodeAnim(r, *iter, samplers[iter.GetIndex()]);
+                ++j;
+            }
+        }
+        
+        // Use the latest keyframe for the duration of the animation
+        double maxDuration = 0;
+        for (unsigned int j = 0; j < ai_anim->mNumChannels; ++j) {
+            auto chan = ai_anim->mChannels[j];
+            if (chan->mNumPositionKeys) {
+                auto lastPosKey = chan->mPositionKeys[chan->mNumPositionKeys - 1];
+                if (lastPosKey.mTime > maxDuration) {
+                    maxDuration = lastPosKey.mTime;
+                }
+            }
+            if (chan->mNumRotationKeys) {
+                auto lastRotKey = chan->mRotationKeys[chan->mNumRotationKeys - 1];
+                if (lastRotKey.mTime > maxDuration) {
+                    maxDuration = lastRotKey.mTime;
+                }
+            }
+            if (chan->mNumScalingKeys) {
+                auto lastScaleKey = chan->mScalingKeys[chan->mNumScalingKeys - 1];
+                if (lastScaleKey.mTime > maxDuration) {
+                    maxDuration = lastScaleKey.mTime;
+                }
+            }
+        }
+        ai_anim->mDuration = maxDuration;
+        
+        mScene->mAnimations[i] = ai_anim;
+    }
+}
+
 void glTF2Importer::ImportEmbeddedTextures(glTF2::Asset& r)
 {
     embeddedTexIdxs.resize(r.images.Size(), -1);
@@ -818,7 +1069,7 @@ void glTF2Importer::ImportEmbeddedTextures(glTF2::Asset& r)
 
     // Add the embedded textures
     for (size_t i = 0; i < r.images.Size(); ++i) {
-        Image img = r.images[i];
+        Image &img = r.images[i];
         if (!img.HasData()) continue;
 
         int idx = mScene->mNumTextures++;
@@ -868,6 +1119,8 @@ void glTF2Importer::InternReadFile(const std::string& pFile, aiScene* pScene, IO
 
     ImportNodes(asset);
 
+    ImportAnimations(asset);
+
     if (pScene->mNumMeshes == 0) {
         pScene->mFlags |= AI_SCENE_FLAGS_INCOMPLETE;
     }