Merge developments from the python_wrapper branch into master

src/ifcexpressparser/bootstrap.py

@@ -170,6 +170,8 @@ import mapping
 import header
 import enum_header
 import implementation
+import latebound_header
+import latebound_implementation
 
 syntax.ignore(Regex(r"\((?:\*(?:[^*]*\*+)+?\))"))
 ast = syntax.parseFile(sys.argv[1])
@@ -179,4 +181,6 @@ mapping = mapping.Mapping(schema)
 header.Header(mapping).emit()
 enum_header.EnumHeader(mapping).emit()
 implementation.Implementation(mapping).emit()
+latebound_header.LateBoundHeader(mapping).emit()
+latebound_implementation.LateBoundImplementation(mapping).emit()
 """%('\n'.join(statements)))

src/ifcexpressparser/enum_header.py

@@ -21,8 +21,7 @@ import templates
 
 class EnumHeader:
     def __init__(self, mapping):
-        selectable_simple_types = sorted(set(sum([b.values for a,b in mapping.schema.selects.items()], [])) & set(mapping.schema.types.keys()))
-        enumerable_types = selectable_simple_types + [name for name, type in mapping.schema.entities.items()]
+        enumerable_types = sorted(set([name for name, type in mapping.schema.types.items()] + [name for name, type in mapping.schema.entities.items()]))
         
         self.str = templates.enum_header % {
             'schema_name_upper' : mapping.schema.name.upper(),

src/ifcexpressparser/header.py

@@ -22,34 +22,34 @@ import documentation
 
 class Header:
     def __init__(self, mapping):
-        emitted_types = set(mapping.express_to_cpp_typemapping.values())
         declarations = []
 
         write = lambda str, **kwargs: declarations.append(str%dict({
             'documentation': templates.multi_line_comment(documentation.description(kwargs['name']))}, **kwargs))
-
-        for name, type in mapping.schema.simpletypes.items():
-            type_str = mapping.make_type_string(type)
-            type_dep = mapping.get_type_dep(type)
-            if type_dep in emitted_types:
-                write(templates.simpletype, name=name, type=type_str)
-                emitted_types.add(name)
-
+            
+        forward_names = list(mapping.schema.entities.keys()) + list(mapping.schema.simpletypes.keys())
+        forward_definitions = "".join(["class %s; "%n for n in forward_names])
+        
         for name, type in mapping.schema.selects.items():
             write(templates.select, name=name)
-            emitted_types.add(name)
-
-        for name, type in mapping.schema.simpletypes.items():
-            if name not in emitted_types:
-                type_str = mapping.make_type_string(type)
-                write(templates.simpletype, name=name, type=type_str)
-                emitted_types.add(name)
 
         for name, type in mapping.schema.enumerations.items():
             short_name = name[:-4] if name.endswith("Enum") else name
             write(templates.enumeration, name=name, values=", ".join(["%s_%s"%(short_name, v) for v in type.values]))
-
-        forward_definitions = "".join(["class %s; "%n for n in mapping.schema.entities.keys()])
+        
+        emitted_simpletypes = set()
+        while len(emitted_simpletypes) < len(mapping.schema.simpletypes):
+            for name, type in mapping.schema.simpletypes.items():
+                if name in emitted_simpletypes: continue
+                type_str = mapping.make_type_string(mapping.flatten_type_string(type))
+                attr_type = mapping.make_argument_type(type)
+                superclass = mapping.simple_type_parent(name)
+                if superclass is None: 
+                    superclass = "IfcUtil::IfcBaseType"
+                elif superclass not in emitted_simpletypes:
+                    continue
+                emitted_simpletypes.add(name)
+                write(templates.simpletype, name=name, type=type_str, attr_type=attr_type, superclass=superclass)
 
         class_definitions = []
 

src/ifcexpressparser/implementation.py

@@ -71,10 +71,11 @@ class Implementation:
                         
                     def find_template(arg):
                         simple = mapping.schema.is_simpletype(arg['list_instance_type'])
+                        select = arg['list_instance_type'] == "IfcUtil::IfcBaseClass"
                         express = arg['list_instance_type'] in mapping.express_to_cpp_typemapping
                         if arg['is_enum']: return templates.get_attr_stmt_enum
                         elif arg['is_nested']: return templates.get_attr_stmt_nested_array
-                        elif arg['is_array'] and not (simple or express): return templates.get_attr_stmt_array
+                        elif arg['is_array'] and not (select or simple or express): return templates.get_attr_stmt_array
                         elif arg['non_optional_type'].endswith('*'): return templates.get_attr_stmt_entity
                         else: return templates.get_attr_stmt
 
@@ -89,8 +90,16 @@ class Implementation:
                                               'type' : arg['non_optional_type'].split('::')[0],
                                               'list_instance_type' : arg['list_instance_type']}
                     )
+                    
+                    def find_template(arg):
+                        simple = mapping.schema.is_simpletype(arg['list_instance_type'])
+                        select = arg['list_instance_type'] == "IfcUtil::IfcBaseClass"
+                        express = arg['list_instance_type'] in mapping.express_to_cpp_typemapping
+                        if arg['is_enum']: return templates.set_attr_stmt_enum
+                        elif arg['is_array'] and not (select or simple or express): return templates.set_attr_stmt_array
+                        else: return templates.set_attr_stmt
 
-                    tmpl = templates.set_attr_stmt_enum if arg['is_enum'] else templates.set_attr_stmt_array if arg['is_array'] and not mapping.schema.is_simpletype(arg['list_instance_type']) and arg['list_instance_type'] not in mapping.express_to_cpp_typemapping else templates.set_attr_stmt
+                    tmpl = find_template(arg)
                     write_attr(
                         templates.function,
                         class_name  = name,
@@ -142,10 +151,10 @@ class Implementation:
             )
 
         selectable_simple_types = sorted(set(sum([b.values for a,b in mapping.schema.selects.items()], [])) & set(mapping.schema.types.keys()))
-        schema_entity_statements += [templates.schema_simple_stmt%locals() for name in selectable_simple_types]
+        schema_entity_statements += [templates.schema_entity_stmt%locals() for name, type in mapping.schema.simpletypes.items()]
         schema_entity_statements += [templates.schema_entity_stmt%locals() for name, type in mapping.schema.entities.items()]
 
-        enumerable_types = selectable_simple_types + [name for name, type in mapping.schema.entities.items()]
+        enumerable_types = sorted(set([name for name, type in mapping.schema.types.items()] + [name for name, type in mapping.schema.entities.items()]))
         max_len = max(map(len, enumerable_types))
         type_name_strings = catc(map(stringify, enumerable_types))
         string_map_statements = [templates.string_map_statement % {
@@ -160,9 +169,40 @@ class Implementation:
             'padding' : ' ' * (max_len - len(name))
         } for name, type in mapping.schema.entities.items() if type.supertypes and len(type.supertypes) == 1]
 
-        max_id = len(schema_entity_statements)
+        max_id = len(enumerable_types)
 
         simple_type_statements = cator("v == Type::%s"%name for name in selectable_simple_types)
+        
+        simple_type_impl = []
+        for class_name, type in mapping.schema.simpletypes.items():
+            type_str = mapping.make_type_string(mapping.flatten_type_string(type))
+            attr_type = mapping.make_argument_type(type)
+            superclass = mapping.simple_type_parent(class_name)
+            
+            simpletype_impl_is = templates.simpletype_impl_is_with_supertype if superclass \
+                else templates.simpletype_impl_is_without_supertype
+                
+            constructor = templates.constructor_single_initlist if superclass \
+                else templates.constructor
+            
+            def compose(params):
+                class_name, attr_type, superclass, superclass_init, name, tmpl, return_type, args, body = params
+                arguments = ",".join(args)
+                body = body % locals()
+                return tmpl % locals()
+                
+            simple_type_impl.append(templates.simpletype_impl_comment % {'name': class_name})
+            simple_type_impl.extend(map(compose, map(lambda x: (class_name, attr_type, superclass, "(IfcAbstractEntity*)0")+x, (
+                ('getArgumentType', templates.const_function,       'IfcUtil::ArgumentType', ('unsigned int i',),       templates.simpletype_impl_argument_type       ),
+                ('getArgument',     templates.const_function,       'Argument*',             ('unsigned int i',),       templates.simpletype_impl_argument            ),
+                ('is',              templates.const_function,       'bool',                  ('Type::Enum v',),                   simpletype_impl_is                  ),
+                ('type',            templates.const_function,       'Type::Enum',            (),                        templates.simpletype_impl_type                ),
+                ('Class',           templates.function,             'Type::Enum',            (),                        templates.simpletype_impl_class               ),
+                ('',                          constructor,          '',                      ('IfcAbstractEntity* e',), templates.simpletype_impl_explicit_constructor),
+                ('',                          constructor,          '',                      ("%s v" % type_str,),      templates.simpletype_impl_constructor         ),
+                ('',                templates.cast_function,        type_str,                (),                        templates.simpletype_impl_cast                )
+            ))))
+            simple_type_impl.append('')
 
         self.str = templates.implementation % {
             'schema_name_upper'        : mapping.schema.name.upper(),
@@ -174,7 +214,8 @@ class Implementation:
             'string_map_statements'    : catnl(string_map_statements),
             'simple_type_statement'    : simple_type_statements,
             'parent_type_statements'   : catnl(parent_type_statements),
-            'entity_implementations'   : catnl(entity_implementations)
+            'entity_implementations'   : catnl(entity_implementations),
+            'simple_type_impl'         : catnl(simple_type_impl)
         }
 
         self.schema_name = mapping.schema.name.capitalize()

src/ifcexpressparser/latebound_header.py

@@ -0,0 +1,35 @@
+###############################################################################
+#                                                                             #
+# This file is part of IfcOpenShell.                                          #
+#                                                                             #
+# IfcOpenShell is free software: you can redistribute it and/or modify        #
+# it under the terms of the Lesser GNU General Public License as published by #
+# the Free Software Foundation, either version 3.0 of the License, or         #
+# (at your option) any later version.                                         #
+#                                                                             #
+# IfcOpenShell is distributed in the hope that it will be useful,             #
+# but WITHOUT ANY WARRANTY; without even the implied warranty of              #
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                #
+# Lesser GNU General Public License for more details.                         #
+#                                                                             #
+# You should have received a copy of the Lesser GNU General Public License    #
+# along with this program. If not, see <http://www.gnu.org/licenses/>.        #
+#                                                                             #
+###############################################################################
+
+import templates
+
+class LateBoundHeader:
+    def __init__(self, mapping):
+        self.str = templates.lb_header % {
+            'schema_name_upper' : mapping.schema.name.upper(),
+            'schema_name'       : mapping.schema.name.capitalize()
+        }
+        
+        self.schema_name = mapping.schema.name.capitalize()
+    def __repr__(self):
+        return self.str
+    def emit(self):
+        f = open('%s-latebound.h'%self.schema_name, 'w', encoding='utf-8')
+        f.write(str(self))
+        f.close()

src/ifcexpressparser/latebound_implementation.py

@@ -0,0 +1,117 @@
+###############################################################################
+#                                                                             #
+# This file is part of IfcOpenShell.                                          #
+#                                                                             #
+# IfcOpenShell is free software: you can redistribute it and/or modify        #
+# it under the terms of the Lesser GNU General Public License as published by #
+# the Free Software Foundation, either version 3.0 of the License, or         #
+# (at your option) any later version.                                         #
+#                                                                             #
+# IfcOpenShell is distributed in the hope that it will be useful,             #
+# but WITHOUT ANY WARRANTY; without even the implied warranty of              #
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                #
+# Lesser GNU General Public License for more details.                         #
+#                                                                             #
+# You should have received a copy of the Lesser GNU General Public License    #
+# along with this program. If not, see <http://www.gnu.org/licenses/>.        #
+#                                                                             #
+###############################################################################
+
+import templates
+
+class LateBoundImplementation:
+    def __init__(self, mapping):
+        schema_name = mapping.schema.name.capitalize()
+        
+        entity_descriptors = []
+        enumeration_descriptors = []
+        derived_field_statements = []
+        inverse_implementations = []
+        
+        for name, type in mapping.schema.simpletypes.items():
+            entity_descriptors.append(templates.entity_descriptor % {
+                'type'                         : name,
+                'parent_statement'             : '0',
+                'entity_descriptor_attributes' : templates.entity_descriptor_attribute % {
+                    'name'     : 'wrappedValue',
+                    'optional' : 'false',
+                    'type'     : mapping.make_argument_type(mapping.schema.types[name].type)
+                }
+            })
+            
+        emitted_entities = set()
+        entities_to_emit = mapping.schema.entities.keys()
+        while len(emitted_entities) < len(mapping.schema.entities):
+            for name, type in mapping.schema.entities.items():
+                if name in emitted_entities: continue
+                if len(type.supertypes) == 0 or set(type.supertypes) < emitted_entities:
+                    constructor_arguments = mapping.get_assignable_arguments(type, include_derived = True)
+                    entity_descriptor_attributes = []
+                    for arg in constructor_arguments:
+                        if not arg['is_inherited']:
+                            tmpl = templates.entity_descriptor_attribute_enum if arg['argument_type_enum'] == 'IfcUtil::Argument_ENUMERATION' else templates.entity_descriptor_attribute
+                            entity_descriptor_attributes.append(tmpl % {
+                                'name'      : arg['name'],
+                                'optional'  : 'true' if arg['is_optional'] else 'false',
+                                'type'      : arg['argument_type_enum'],
+                                'enum_type' : arg['argument_type']
+                            })
+                        
+                    emitted_entities.add(name)
+                    parent_statement = '0' if len(type.supertypes) != 1 else templates.entity_descriptor_parent % {
+                        'type' : type.supertypes[0]
+                    }
+                    entity_descriptors.append(templates.entity_descriptor % {
+                        'type'                         : name,
+                        'parent_statement'             : parent_statement,
+                        'entity_descriptor_attributes' : '\n'.join(entity_descriptor_attributes)
+                    })
+                    
+        for name, enum in mapping.schema.enumerations.items():
+            enumeration_descriptor_values = '\n'.join([templates.enumeration_descriptor_value % {
+                'name' : v
+            } for v in enum.values])
+            enumeration_descriptors.append(templates.enumeration_descriptor % {
+                'type'                          : name,
+                'enumeration_descriptor_values' : enumeration_descriptor_values
+            })
+            
+        for name, type in mapping.schema.entities.items():
+            constructor_arguments = mapping.get_assignable_arguments(type, include_derived = True)
+            statements = ''.join(templates.derived_field_statement_attrs % (a['index']-1) for a in constructor_arguments if a['is_derived'])
+            if len(statements):
+                derived_field_statements.append(templates.derived_field_statement % {
+                    'type'       : name,
+                    'statements' : statements
+                })
+                
+        for name, type in mapping.schema.entities.items():
+            if type.inverse:
+                for attr in type.inverse.elements:
+                    related_entity = mapping.schema.entities[attr.entity]
+                    related_attrs = [a['name'] for a in mapping.get_assignable_arguments(related_entity, include_derived=True)]
+
+                    inverse_implementations.append(templates.inverse_implementation % {
+                        'type'         : name,
+                        'name'         : attr.name,
+                        'related_type' : attr.entity,
+                        'index'        : related_attrs.index(attr.attribute)
+                    })
+
+        self.str = templates.lb_implementation % {
+            'schema_name_upper'        : mapping.schema.name.upper(),
+            'schema_name'              : mapping.schema.name.capitalize(),
+            'entity_descriptors'       : '\n'.join(entity_descriptors),
+            'enumeration_descriptors'  : '\n'.join(enumeration_descriptors),
+            'derived_field_statements' : '\n'.join(derived_field_statements),
+            'inverse_implementations'  : '\n'.join(inverse_implementations)
+        }
+
+        self.schema_name = mapping.schema.name.capitalize()
+    def __repr__(self):
+        return self.str
+    def emit(self):
+        f = open('%s-latebound.cpp'%self.schema_name, 'w', encoding='utf-8')
+        f.write(str(self))
+        f.close()
+

src/ifcexpressparser/mapping.py

@@ -33,6 +33,18 @@ class Mapping:
 
     def __init__(self, schema):
         self.schema = schema
+        
+    def flatten_type_string(self, type):
+        return self.flatten_type_string(self.schema.types[type].type.type) if self.schema.is_simpletype(type) else type
+        
+    def flatten_type(self, type):
+        res = self.flatten_type(self.schema.types[type].type.type) if self.schema.is_simpletype(type) else type
+        return res
+        
+    def simple_type_parent(self, type):
+        parent = self.schema.types[type].type.type
+        if isinstance(parent, nodes.AggregationType): parent = None
+        return None if parent in self.express_to_cpp_typemapping else parent
 
     def make_type_string(self, type):
         if isinstance(type, str):
@@ -75,7 +87,7 @@ class Mapping:
                 return "%s_LIST"%ty if ty.startswith("ENTITY") else ("VECTOR_%s"%ty)
             else: raise ValueError
         supported = {'INT', 'BOOL', 'DOUBLE', 'STRING', 'VECTOR_INT', 'VECTOR_DOUBLE', 'VECTOR_STRING', 'ENTITY', 'ENTITY_LIST', 'ENTITY_LIST_LIST', 'ENUMERATION'}
-        ty = _make_argument_type(attr.type)
+        ty = _make_argument_type(attr.type if hasattr(attr, 'type') else attr)
         if ty not in supported: ty = 'UNKNOWN'
         return "IfcUtil::Argument_%s" % ty
 
@@ -86,31 +98,35 @@ class Mapping:
             return self.get_type_dep(type.type)
 
     def get_parameter_type(self, attr, allow_optional, allow_entities, allow_pointer = True):
-        type_str = self.express_to_cpp_typemapping.get(str(attr.type), attr.type)
+        
+        attr_type = self.flatten_type(attr.type)
+        type_str = self.express_to_cpp_typemapping.get(str(attr_type), attr_type)
+        
         is_ptr = False
-        if self.schema.is_enumeration(attr.type):
-            type_str = '%s::%s'%(attr.type, attr.type)
+        
+        if self.schema.is_enumeration(attr_type):
+            type_str = '%s::%s'%(attr_type, attr_type)
         elif isinstance(type_str, nodes.AggregationType):
-            is_nested_list = isinstance(attr.type.type, nodes.AggregationType)
-            ty = self.get_parameter_type(attr.type.type if is_nested_list else attr.type, False, allow_entities, allow_pointer=False)
-            if allow_entities and self.schema.is_select(attr.type.type):
+            is_nested_list = isinstance(attr_type.type, nodes.AggregationType)
+            ty = self.get_parameter_type(attr_type.type if is_nested_list else attr_type, False, allow_entities, False)
+            if True and self.schema.is_select(attr_type.type):
                 type_str = templates.untyped_list
             elif self.schema.is_simpletype(ty) or ty in self.express_to_cpp_typemapping.values():
                 type_str = templates.array_type % {
                     'instance_type' : ty,
-                    'lower'         : attr.type.bounds.lower,
-                    'upper'         : attr.type.bounds.upper
+                    'lower'         : attr_type.bounds.lower,
+                    'upper'         : attr_type.bounds.upper
                 }
             else:
                 tmpl = templates.list_list_type if is_nested_list else templates.list_type
                 type_str = tmpl % {
                     'instance_type': ty
                 }
-        elif allow_pointer and self.schema.is_entity(type_str):
+        elif allow_pointer and (self.schema.is_entity(type_str) or self.schema.is_select(type_str)):
             type_str += '*'
             is_ptr = True
         elif not allow_pointer and self.schema.is_select(type_str):
-            type_str = "IfcUtil::IfcAbstractSelect"
+            type_str = "IfcUtil::IfcBaseClass*"
             is_ptr = True
         if allow_optional and attr.optional and not is_ptr:
             type_str = "boost::optional< %s >"%type_str
@@ -129,7 +145,7 @@ class Mapping:
         return c + ([str(s) for s in t.derive.elements] if t.derive else [])
 
     def list_instance_type(self, attr):
-        f = lambda v : 'IfcUtil::IfcAbstractSelect' if self.schema.is_select(v) else v
+        f = lambda v : 'IfcUtil::IfcBaseClass' if self.schema.is_select(v) else v
         if self.is_array(attr.type):
             if not isinstance(attr.type, str) and self.is_array(attr.type.type):
                 if isinstance(attr.type.type, str):
@@ -146,7 +162,7 @@ class Mapping:
         arr = self.is_array(attr.type)
         simple = self.schema.is_simpletype(ty)
         express = ty in self.express_to_cpp_typemapping
-        select = ty == 'IfcUtil::IfcAbstractSelect'
+        select = ty == 'IfcUtil::IfcBaseClass'
         return arr and not simple and not express and not select
 
     def get_assignable_arguments(self, t, include_derived = False):
@@ -173,6 +189,8 @@ class Mapping:
             'is_array'           : self.is_array(attr.type),
             'is_nested'          : self.is_array(attr.type) and not isinstance(attr.type, str) and self.is_array(attr.type.type),
             'is_derived'         : attr.name in derived,
-            'is_templated_list'  : self.is_templated_list(attr)
+            'is_templated_list'  : self.is_templated_list(attr),
+            'argument_type_enum' : self.make_argument_type(attr),
+            'argument_type'      : attr.type
         } for i, attr in attrs if include(attr)]
 

src/ifcexpressparser/templates.py

@@ -71,6 +71,33 @@ namespace Type {
 #endif
 """
 
+lb_header = """
+#ifndef %(schema_name_upper)sRT_H
+#define %(schema_name_upper)sRT_H
+
+#define IfcSchema %(schema_name)s
+
+#include "../ifcparse/IfcUtil.h"
+#include "../ifcparse/IfcEntityDescriptor.h"
+#include "../ifcparse/IfcWritableEntity.h"
+
+namespace %(schema_name)s {
+namespace Type {
+    int GetAttributeCount(Enum t);
+    int GetAttributeIndex(Enum t, const std::string& a);
+    IfcUtil::ArgumentType GetAttributeType(Enum t, unsigned char a);
+    const std::string& GetAttributeName(Enum t, unsigned char a);
+    bool GetAttributeOptional(Enum t, unsigned char a);
+    bool GetAttributeDerived(Enum t, unsigned char a);
+    std::pair<const char*, int> GetEnumerationIndex(Enum t, const std::string& a);
+    std::pair<Enum, unsigned> GetInverseAttribute(Enum t, const std::string& a);
+    Enum GetAttributeEnumerationClass(Enum t, unsigned char a);
+    void PopulateDerivedFields(IfcWrite::IfcWritableEntity* e);
+}}
+
+#endif
+"""
+
 implementation= """
 #include "../ifcparse/%(schema_name)s.h"
 #include "../ifcparse/IfcException.h"
@@ -100,6 +127,7 @@ void %(schema_name)s::InitStringMap() {
 }
 
 Type::Enum Type::FromString(const std::string& s) {
+    if (string_map.empty()) InitStringMap();
     std::map<std::string,Type::Enum>::const_iterator it = string_map.find(s);
     if ( it == string_map.end() ) throw IfcException("Unable to find find keyword in schema");
     else return it->second;
@@ -117,15 +145,173 @@ bool Type::IsSimple(Enum v) {
 
 %(enumeration_functions)s
 
+%(simple_type_impl)s
+
 %(entity_implementations)s
 """
 
-simpletype = """%(documentation)s
-typedef %(type)s %(name)s;
+lb_implementation = """
+#include <set>
+
+#include "../ifcparse/%(schema_name)s.h"
+#include "../ifcparse/%(schema_name)s-latebound.h"
+#include "../ifcparse/IfcException.h"
+#include "../ifcparse/IfcWrite.h"
+#include "../ifcparse/IfcWritableEntity.h"
+#include "../ifcparse/IfcUtil.h"
+#include "../ifcparse/IfcEntityDescriptor.h"
+
+using namespace %(schema_name)s;
+using namespace IfcParse;
+using namespace IfcWrite;
+using namespace IfcUtil;
+
+std::map<Type::Enum,IfcEntityDescriptor*> entity_descriptor_map;
+std::map<Type::Enum,IfcEnumerationDescriptor*> enumeration_descriptor_map;
+std::map<std::pair<Type::Enum, std::string>, std::pair<Type::Enum, int> > inverse_map;
+std::map<Type::Enum,std::set<int> > derived_map;
+
+void InitDescriptorMap() {
+    IfcEntityDescriptor* current;
+%(entity_descriptors)s
+    // Enumerations
+    IfcEnumerationDescriptor* current_enum;
+    std::vector<std::string> values;
+%(enumeration_descriptors)s
+}
+
+void InitInverseMap() {
+%(inverse_implementations)s
+}
+
+void InitDerivedMap() {
+%(derived_field_statements)s
+}
+
+int Type::GetAttributeIndex(Enum t, const std::string& a) {
+    if (entity_descriptor_map.empty()) ::InitDescriptorMap();
+    std::map<Type::Enum,IfcEntityDescriptor*>::const_iterator i = entity_descriptor_map.find(t);
+    if ( i == entity_descriptor_map.end() ) throw IfcException("Type not found");
+    else return i->second->getArgumentIndex(a);
+}
+
+int Type::GetAttributeCount(Enum t) {
+    if (entity_descriptor_map.empty()) ::InitDescriptorMap();
+    std::map<Type::Enum,IfcEntityDescriptor*>::const_iterator i = entity_descriptor_map.find(t);
+    if ( i == entity_descriptor_map.end() ) throw IfcException("Type not found");
+    else return i->second->getArgumentCount();
+}
+
+ArgumentType Type::GetAttributeType(Enum t, unsigned char a) {
+    if (entity_descriptor_map.empty()) ::InitDescriptorMap();
+    std::map<Type::Enum,IfcEntityDescriptor*>::const_iterator i = entity_descriptor_map.find(t);
+    if ( i == entity_descriptor_map.end() ) throw IfcException("Type not found");
+    else return i->second->getArgumentType(a);
+}
+
+const std::string& Type::GetAttributeName(Enum t, unsigned char a) {
+    if (entity_descriptor_map.empty()) ::InitDescriptorMap();
+    std::map<Type::Enum,IfcEntityDescriptor*>::const_iterator i = entity_descriptor_map.find(t);
+    if ( i == entity_descriptor_map.end() ) throw IfcException("Type not found");
+    else return i->second->getArgumentName(a);
+}
+
+bool Type::GetAttributeOptional(Enum t, unsigned char a) {
+    if (entity_descriptor_map.empty()) ::InitDescriptorMap();
+    std::map<Type::Enum,IfcEntityDescriptor*>::const_iterator i = entity_descriptor_map.find(t);
+    if ( i == entity_descriptor_map.end() ) throw IfcException("Type not found");
+    else return i->second->getArgumentOptional(a);
+}
+
+bool Type::GetAttributeDerived(Enum t, unsigned char a) {
+    if (derived_map.empty()) ::InitDerivedMap();
+    std::map<Type::Enum,std::set<int> >::const_iterator i = derived_map.find(t);
+    return i != derived_map.end() && i->second.find(a) != i->second.end();
+}
+
+std::pair<const char*, int> Type::GetEnumerationIndex(Enum t, const std::string& a) {
+    if (enumeration_descriptor_map.empty()) ::InitDescriptorMap();
+    std::map<Type::Enum,IfcEnumerationDescriptor*>::const_iterator i = enumeration_descriptor_map.find(t);
+    if ( i == enumeration_descriptor_map.end() ) throw IfcException("Value not found");
+    else return i->second->getIndex(a);
+}
+
+std::pair<Type::Enum, unsigned> Type::GetInverseAttribute(Enum t, const std::string& a) {
+	if (inverse_map.empty()) ::InitInverseMap();
+	std::map<std::pair<Type::Enum, std::string>, std::pair<Type::Enum, int> >::const_iterator it;
+    std::pair<Type::Enum, std::string> key = std::make_pair(t, a);
+    while (true) {
+        it = inverse_map.find(key);
+        if (it != inverse_map.end()) return it->second;
+        if ((key.first = Parent(key.first)) == -1) break;
+    }
+    throw IfcException("Attribute not found");
+}
+
+Type::Enum Type::GetAttributeEnumerationClass(Enum t, unsigned char a) {
+    if (entity_descriptor_map.empty()) ::InitDescriptorMap();
+    std::map<Type::Enum,IfcEntityDescriptor*>::const_iterator i = entity_descriptor_map.find(t);
+    if ( i == entity_descriptor_map.end() ) throw IfcException("Type not found");
+    else {
+        Type::Enum t = i->second->getArgumentEnumerationClass(a);
+        if ( t == Type::ALL ) throw IfcException("Not an enumeration");
+        else return t;
+    }
+}
+
+void Type::PopulateDerivedFields(IfcWrite::IfcWritableEntity* e) {
+    std::map<Type::Enum, std::set<int> >::const_iterator i = derived_map.find(e->type());
+	if (i != derived_map.end()) {
+		for (std::set<int>::const_iterator it = i->second.begin(); it != i->second.end(); ++it) {
+			e->setArgumentDerived(*it);
+		}
+	}
+}
 """
 
+entity_descriptor = """    current = entity_descriptor_map[Type::%(type)s] = new IfcEntityDescriptor(Type::%(type)s,%(parent_statement)s);
+%(entity_descriptor_attributes)s"""
+
+entity_descriptor_parent = "entity_descriptor_map.find(Type::%(type)s)->second"
+entity_descriptor_attribute = '    current->add("%(name)s",%(optional)s,%(type)s);'
+entity_descriptor_attribute_enum = '    current->add("%(name)s",%(optional)s,%(type)s,Type::%(enum_type)s);'
+
+enumeration_descriptor = """    values.clear(); values.reserve(128);
+%(enumeration_descriptor_values)s
+    current_enum = enumeration_descriptor_map[Type::%(type)s] = new IfcEnumerationDescriptor(Type::%(type)s, values);"""
+
+enumeration_descriptor_value = '    values.push_back("%(name)s");'
+
+derived_field_statement = '    {std::set<int> idxs; %(statements)sderived_map[Type::%(type)s] = idxs;}';
+derived_field_statement_attrs = 'idxs.insert(%d); '
+
+simpletype = """%(documentation)s
+class %(name)s : public %(superclass)s {
+public:
+    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const;
+    virtual Argument* getArgument(unsigned int i) const;
+    bool is(Type::Enum v) const;
+    Type::Enum type() const;
+    static Type::Enum Class();
+    explicit %(name)s (IfcAbstractEntity* e);
+    %(name)s (%(type)s v);
+    operator %(type)s() const;
+};
+"""
+
+simpletype_impl_comment = "// Function implementations for %(name)s"
+simpletype_impl_argument_type = "if (i == 0) { return %(attr_type)s; } else { throw IfcParse::IfcException(\"argument out of range\"); }"
+simpletype_impl_argument = "return entity->getArgument(i);"
+simpletype_impl_is_with_supertype = "return v == Type::%(class_name)s || %(superclass)s::is(v);"
+simpletype_impl_is_without_supertype = "return v == %(class_name)s::Class();"
+simpletype_impl_type = "return Type::%(class_name)s;"
+simpletype_impl_class = "return Type::%(class_name)s;"
+simpletype_impl_explicit_constructor = "entity = e;"
+simpletype_impl_constructor = "IfcWritableEntity* e = new IfcWritableEntity(Type::%(class_name)s); e->setArgument(0, v); entity = e;"
+simpletype_impl_cast = "return *entity->getArgument(0);"    
+    
 select = """%(documentation)s
-typedef IfcUtil::IfcBaseClass* %(name)s;
+typedef IfcUtil::IfcBaseClass %(name)s;
 """
 
 enumeration = """namespace %(name)s {
@@ -177,6 +363,9 @@ optional_attribute_description = "/// Whether the optional attribute %s is defin
 
 function = "%(return_type)s %(class_name)s::%(name)s(%(arguments)s) { %(body)s }"
 const_function = "%(return_type)s %(class_name)s::%(name)s(%(arguments)s) const { %(body)s }"
+constructor = "%(class_name)s::%(class_name)s(%(arguments)s) { %(body)s }"
+constructor_single_initlist = "%(class_name)s::%(class_name)s(%(arguments)s) : %(superclass)s(%(superclass_init)s) { %(body)s }"
+cast_function = "%(class_name)s::operator %(return_type)s() const { %(body)s }"
 
 array_type = "std::vector< %(instance_type)s > /*[%(lower)s:%(upper)s]*/"
 list_type = "IfcTemplatedEntityList< %(instance_type)s >::ptr"
@@ -213,6 +402,8 @@ constructor_stmt_array = " e->setArgument(%(index)d,(%(name)s)->generalize());"
 constructor_stmt_optional = " if (%(name)s) {%(stmt)s } else { e->setArgument(%(index)d); }"
 constructor_stmt_derived = " e->setArgumentDerived(%(index)d);"
 
+inverse_implementation = "    inverse_map.insert(std::make_pair(std::make_pair(Type::%(type)s, \"%(name)s\"), std::make_pair(Type::%(related_type)s, %(index)d)));"
+
 def multi_line_comment(li):
     return ("/// %s"%("\n/// ".join(li))) if len(li) else ""