Rough merge of schema runtime representation

src/ifcexpressparser/bootstrap.py

@@ -121,7 +121,7 @@ actions = {
     'general_aggregation_types' : "lambda t: AggregationType(t)",
     'select_type'               : "lambda t: SelectType(t)",
     'binary_type'               : "lambda t: BinaryType(t)",
-    'subtype_declaration'       : "lambda t: SubtypeExpression(t)",
+    'subtype_declaration'       : "lambda t: SubTypeExpression(t)",
     'derive_clause'             : "lambda t: AttributeList('derive', t)",
     'derived_attr'              : "lambda t: DerivedAttribute(t)",
     'inverse_clause'            : "lambda t: AttributeList('inverse', t)",
@@ -170,32 +170,45 @@ for id in to_emit:
         stmt = "Suppress%s" % stmt
     statements.append("%s << %s" % (id, stmt))
 
-print ("""import sys
-from pyparsing import *
-from nodes import *
+print ("""import os
+import sys
+import pickle
 
-%s
+cache_file = sys.argv[1] + ".cache.dat"
+if os.path.exists(cache_file):
+    with open(cache_file, "rb") as f:
+        mapping = pickle.load(f)
+else:
+    from pyparsing import *
+    from nodes import *
+    
+    import schema
+    import mapping
+    
+    %s
 
-import schema
-import mapping
+    syntax.ignore("--" + restOfLine)
+    syntax.ignore(Regex(r"\((?:\*(?:[^*]*\*+)+?\))"))
+    ast = syntax.parseFile(sys.argv[1])
+    schema = schema.Schema(ast)
+    mapping = mapping.Mapping(schema)
+
+    with open(cache_file, "wb") as f:
+        pickle.dump(mapping, f, protocol=0)    
 
 import header
 import enum_header
 import implementation
 import latebound_header
 import latebound_implementation
-
-syntax.ignore("--" + restOfLine)
-syntax.ignore(Regex(r"\((?:\*(?:[^*]*\*+)+?\))"))
-ast = syntax.parseFile(sys.argv[1])
-schema = schema.Schema(ast)
-mapping = mapping.Mapping(schema)
+import schema_class
 
 header.Header(mapping).emit()
 enum_header.EnumHeader(mapping).emit()
 implementation.Implementation(mapping).emit()
 latebound_header.LateBoundHeader(mapping).emit()
 latebound_implementation.LateBoundImplementation(mapping).emit()
+schema_class.SchemaClass(mapping).emit()
 
 sys.stdout.write(schema.name)
-"""%('\n'.join(statements)))
+"""%('\n    '.join(statements)))

src/ifcexpressparser/implementation.py

@@ -210,16 +210,16 @@ class Implementation(codegen.Base):
                 
             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, "(IfcEntityInstanceData*)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               ),
+                ('declaration',     templates.const_function,       'const IfcParse::type_declaration&', (),                templates.simpletype_impl_declaration         ),
                 ('',                          constructor,          '',                      ('IfcEntityInstanceData* e',), templates.simpletype_impl_explicit_constructor),
                 ('',                          constructor,          '',                      ("%s v" % type_str,),          simpletype_impl_constructor                   ),
                 ('',                templates.cast_function,        type_str,                (),                            simpletype_impl_cast                          )
             ))))
             simple_type_impl.append('')
+            
+        external_definitions = ["extern entity* %s_type;"           % n for n in mapping.schema.entities.keys()   ] + \
+                               ["extern type_declaration* %s_type;" % n for n in mapping.schema.simpletypes.keys()]
 
         self.str = templates.implementation % {
             'schema_name_upper'        : mapping.schema.name.upper(),
@@ -232,7 +232,8 @@ class Implementation(codegen.Base):
             'simple_type_statement'    : simple_type_statements,
             'parent_type_statements'   : parent_type_statements,
             'entity_implementations'   : catnl(entity_implementations),
-            'simple_type_impl'         : catnl(simple_type_impl)
+            'simple_type_impl'         : catnl(simple_type_impl),
+            'external_definitions'     : catnl(external_definitions)
         }
 
         self.schema_name = mapping.schema.name.capitalize()

src/ifcexpressparser/nodes.py

@@ -44,15 +44,17 @@ class TypeDeclaration(Node):
 class EntityDeclaration(Node):
     name = property(lambda self: self.tokens[1])
     attributes = property(lambda self: self.tokens_of_type(ExplicitAttribute))
+    abstract = property(lambda self: self.single_token_of_type(SuperTypeExpression) is not None and \
+        self.single_token_of_type(SuperTypeExpression).abstract)
     def init(self):
         assert self.tokens[0] == 'entity'
-        s = self.single_token_of_type(SubtypeExpression)
+        s = self.single_token_of_type(SubTypeExpression)
         self.inverse = self.single_token_of_type(AttributeList, 'type', 'inverse')
         self.derive = self.single_token_of_type(AttributeList, 'type', 'derive')
         self.supertypes = s.types if s else []
     def __repr__(self):
         builder = ""
-        builder += "Entity(%s)" % (self.name)
+        builder += "%sEntity(%s)" % ("Abstract " if self.abstract else "", self.name)
         if len(self.supertypes):
             builder += "\n  Supertypes: %s"%(",".join(self.supertypes))
         if len(self.attributes):
@@ -106,12 +108,20 @@ class SelectType(Node):
 class SubSuperTypeExpression(Node):
     type = property(lambda self: self.tokens[0])
     types = property(lambda self: self.tokens[3::2])
+    abstract = False
     def init(self):
-        assert self.type == self.class_type
+        if self.tokens[0] == 'abstract':
+            self.tokens = self.tokens[1:]
+            self.abstract = True
+        assert self.type == self.type_relationship
 
 
-class SubtypeExpression(SubSuperTypeExpression):
-    class_type = 'subtype'
+class SubTypeExpression(SubSuperTypeExpression):
+    type_relationship = 'subtype'
+
+
+class SuperTypeExpression(SubSuperTypeExpression):
+    type_relationship = 'supertype'
 
 
 class AttributeList(Node):

src/ifcexpressparser/schema.py

@@ -27,25 +27,27 @@ if tuple(map(int, platform.python_version_tuple())) < (2, 7):
     
 # According to ISO 10303-11 7.1.2: Letters: "... The case of 
 # letters is significant only within explicit string literals."
+class OrderedCaseInsensitiveDict_KeyObject(str):
+    def __eq__(self, other):
+        return self.lower() == other.lower()
+    def __hash__(self):
+        return hash(self.lower())
+
+
 class OrderedCaseInsensitiveDict(collections.OrderedDict):
-    class KeyObject(str):
-        def __eq__(self, other):
-            return self.lower() == other.lower()
-        def __hash__(self):
-            return hash(self.lower())
-            
     def __init__(self, *args, **kwargs):
         collections.OrderedDict.__init__(self)
         for key, value in collections.OrderedDict(*args, **kwargs).items():
-            self[OrderedCaseInsensitiveDict.KeyObject(key)] = value
+            self[OrderedCaseInsensitiveDict_KeyObject(key)] = value
     def __setitem__(self, key, value):
-        return collections.OrderedDict.__setitem__(self, OrderedCaseInsensitiveDict.KeyObject(key), value)
+        return collections.OrderedDict.__setitem__(self, OrderedCaseInsensitiveDict_KeyObject(key), value)
     def __getitem__(self, key):
-        return collections.OrderedDict.__getitem__(self, OrderedCaseInsensitiveDict.KeyObject(key))
+        return collections.OrderedDict.__getitem__(self, OrderedCaseInsensitiveDict_KeyObject(key))
     def get(self, key, *args, **kwargs):
-        return collections.OrderedDict.get(self, OrderedCaseInsensitiveDict.KeyObject(key), *args, **kwargs)
+        return collections.OrderedDict.get(self, OrderedCaseInsensitiveDict_KeyObject(key), *args, **kwargs)
     def __contains__(self, key):
-        return collections.OrderedDict.__contains__(self, OrderedCaseInsensitiveDict.KeyObject(key))
+        return collections.OrderedDict.__contains__(self, OrderedCaseInsensitiveDict_KeyObject(key))
+
 
 class Schema:
     def is_enumeration(self, v):

src/ifcexpressparser/schema_class.py

@@ -0,0 +1,199 @@
+###############################################################################
+#                                                                             #
+# 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 operator
+
+import nodes
+import codegen
+import templates
+
+class SchemaClass(codegen.Base):
+    def __init__(self, mapping):
+        
+        class UnmetDependenciesException(Exception): pass
+        
+        schema_name = mapping.schema.name
+        declared_types = []
+        
+        def get_declared_type(type, emitted_names=None):
+            if isinstance(type, nodes.AggregationType):
+                aggr_type = type.aggregate_type
+                make_bound = lambda b: -1 if b == '?' else int(b)
+                bound1, bound2 = map(make_bound, (type.bounds.lower, type.bounds.upper))
+                decl_type = get_declared_type(type.type)
+                return "new aggregation_type(aggregation_type::%(aggr_type)s_type, %(bound1)d, %(bound2)d, %(decl_type)s)" % locals()
+            elif isinstance(type, nodes.BinaryType):
+                return "new simple_type(simple_type::binary_type)"
+            elif isinstance(type, str):
+                if mapping.schema.is_type(type) or mapping.schema.is_entity(type):
+                    if emitted_names is None or type in emitted_types:
+                        return "new named_type(%s_type)" % type
+                    else:
+                        raise UnmetDependenciesException(type)
+                else:
+                    return "new simple_type(simple_type::%s_type)" % type
+
+        def find_inverse_name_and_index(entity_name, attribute_name):
+            attributes_per_subtype = []
+            while True:
+                entity = mapping.schema.entities[entity_name]
+                attr_names = list(map(operator.attrgetter('name'), entity.attributes))
+                if len(attr_names):
+                    attributes_per_subtype.append((entity_name, attr_names))
+                if len(entity.supertypes) != 1: break
+                entity_name = entity.supertypes[0]
+            index = 0
+            for et, attrs in attributes_per_subtype[::-1]:
+                try: return et, attrs.index(attribute_name)
+                except: pass
+    
+        self.schema_name = mapping.schema.name.capitalize()
+        
+        statements = ['',
+                      '#include "../ifcparse/IfcSchema.h"',
+                      '',
+                      'using namespace IfcParse;'
+                      '']
+
+        collections_by_type = (('entity',           mapping.schema.entities    ),
+                               ('type_declaration', mapping.schema.simpletypes ),
+                               ('select_type',      mapping.schema.selects     ),
+                               ('enumeration_type', mapping.schema.enumerations))
+
+        for cpp_type, collection in collections_by_type:
+            for name in collection.keys():
+                statements.append('%(cpp_type)s* %(name)s_type = 0;' % locals())
+                
+        statements.append('#ifdef _MSC_VER'          )
+        statements.append('#pragma optimize("", off)')
+        statements.append('#endif'                   )
+                          
+        statements.append('schema_definition* populate_schema() {')
+        
+        emitted_types = set()
+        while len(emitted_types) < len(mapping.schema.simpletypes):
+            for name, type in mapping.schema.simpletypes.items():
+                if name in emitted_types: continue
+                
+                try:
+                    declared_type = get_declared_type(type, emitted_types)
+                except UnmetDependenciesException:
+                    continue
+
+                statements.append('    %(name)s_type = new type_declaration(IfcSchema::Type::%(name)s, %(declared_type)s);' % locals())
+                emitted_types.add(name)
+                
+                declared_types.append('%(name)s_type' % locals())
+                
+        for name, enum in mapping.schema.enumerations.items():
+            statements.append('    {')
+            statements.append('        std::vector<std::string> items; items.reserve(%d);' % len(enum.values))
+            statements.extend(map(lambda v: '        items.push_back("%s");' % v, sorted(enum.values)))
+            statements.append('        %(name)s_type = new enumeration_type(IfcSchema::Type::%(name)s, items);' % locals())
+            statements.append('    }')
+            
+            declared_types.append('%(name)s_type' % locals())
+        
+        emitted_entities = set()
+        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:
+                    supertype = '0' if len(type.supertypes) == 0 else '%s_type' % type.supertypes[0]
+                    statements.append('    %(name)s_type = new entity(IfcSchema::Type::%(name)s, %(supertype)s);' % locals())
+                    emitted_entities.add(name)
+                    
+                    declared_types.append('%(name)s_type' % locals())
+        
+        emmited = emitted_types | emitted_entities | set(mapping.schema.enumerations.keys())
+        
+        emitted_selects = set()
+        while len(emitted_selects) < len(mapping.schema.selects):
+            for name, type in mapping.schema.selects.items():
+                if name in emitted_selects: continue
+                if set(type.values) < emmited:
+                    statements.append('    {')
+                    statements.append('        std::vector<const declaration*> items; items.reserve(%d);' % len(type.values))
+                    statements.extend(map(lambda v: '        items.push_back(%s_type);' % v, sorted(type.values)))
+                    statements.append('        %(name)s_type = new select_type(IfcSchema::Type::%(name)s, items);' % locals())
+                    statements.append('    }')
+                    emitted_selects.add(name)
+                    emmited.add(name)
+                    
+                    declared_types.append('%(name)s_type' % locals())
+                    
+        num_declarations = len(declared_types)
+                    
+        for name, type in mapping.schema.entities.items():
+            derived = set(mapping.derived_in_supertype(type))
+            attribute_names = list(map(operator.attrgetter('name'), mapping.arguments(type)))
+            
+            statements.append('    {')
+            statements.append('        std::vector<const entity::attribute*> attributes; attributes.reserve(%d);' % len(type.attributes))
+            for attr in type.attributes:
+                attr_name, optional = attr.name, str(attr.optional).lower()
+                decl_type = get_declared_type(attr.type)
+                statements.append('        attributes.push_back(new entity::attribute("%(attr_name)s", %(decl_type)s, %(optional)s));' % locals())
+            statements.append('        std::vector<bool> derived; derived.reserve(%d);' % len(attribute_names))
+            statements.append('        ' + " ".join(map(lambda b: 'derived.push_back(%s);' % str(b in derived).lower(), attribute_names)))
+            statements.append('        %(name)s_type->set_attributes(attributes, derived);' % locals())
+            statements.append('    }')
+            
+        for name, type in mapping.schema.entities.items():
+            if type.inverse:
+                statements.append('    {')
+                statements.append('        std::vector<const entity::inverse_attribute*> attributes; attributes.reserve(%d);' % len(type.inverse.elements))
+                for attr in type.inverse.elements:
+                    if attr.bounds:
+                        make_bound = lambda b: -1 if b == '?' else int(b)
+                        bound1, bound2 = map(make_bound, (attr.bounds.lower, attr.bounds.upper))
+                    else:
+                        bound1, bound2 = -1, -1
+                    attr_name, aggr_type, entity_ref = attr.name, attr.type, attr.entity
+                    if aggr_type is None: aggr_type = 'unspecified'
+                    attribute_entity, attribute_entity_index = find_inverse_name_and_index(entity_ref, attr.attribute)
+                    statements.append('        attributes.push_back(new entity::inverse_attribute("%(attr_name)s", entity::inverse_attribute::%(aggr_type)s_type, %(bound1)d, %(bound2)d, %(entity_ref)s_type, %(attribute_entity)s_type->attributes()[%(attribute_entity_index)d]));' % locals())
+                statements.append('        %(name)s_type->set_inverse_attributes(attributes);' % locals())
+                statements.append('    }')
+            
+        statements.append('')
+        statements.append('    std::vector<const declaration*> declarations; declarations.reserve(%(num_declarations)d);' % locals())
+        for type_name in declared_types:
+            statements.append('    declarations.push_back(%(type_name)s);' % locals())
+            
+        statements.append('    return new schema_definition("%(schema_name)s", declarations, true);' % locals())
+        
+        statements.extend(('}',''))
+        
+        statements.append('#ifdef _MSC_VER'         )
+        statements.append('#pragma optimize("", on)')
+        statements.append('#endif'                  )
+        
+        statements.extend(('const schema_definition& get_schema() {',
+                           '',
+                           '    static const schema_definition* s = populate_schema();',
+                           '    return *s;',
+                           '}','',''))
+                           
+        self.str = "\n".join(statements)
+        
+        self.file_name = '%s-schema.cpp'%self.schema_name
+
+    def __repr__(self):
+        return self.str

src/ifcexpressparser/templates.py

@@ -30,11 +30,14 @@ header = """
 
 #include "../ifcparse/IfcEntityList.h"
 #include "../ifcparse/IfcBaseClass.h"
+#include "../ifcparse/IfcSchema.h"
 #include "../ifcparse/IfcException.h"
 #include "../ifcparse/Argument.h"
 
 #include "../ifcparse/%(schema_name)senum.h"
 
+const IfcParse::schema_definition& get_schema();
+
 #define IfcSchema %(schema_name)s
 
 namespace %(schema_name)s {
@@ -112,6 +115,7 @@ namespace Type {
 
 implementation= """
 #include "../ifcparse/%(schema_name)s.h"
+#include "../ifcparse/IfcSchema.h"
 #include "../ifcparse/IfcException.h"
 #include "../ifcparse/IfcWrite.h"
 
@@ -121,6 +125,9 @@ using namespace %(schema_name)s;
 using namespace IfcParse;
 using namespace IfcWrite;
 
+// External definitions
+%(external_definitions)s
+
 IfcUtil::IfcBaseClass* %(schema_name)s::SchemaEntity(IfcEntityInstanceData* e) {
     switch(e->type()) {
 %(schema_entity_statements)s
@@ -353,10 +360,7 @@ derived_field_statement_attrs = 'idxs.insert(%d); '
 simpletype = """%(documentation)s
 class IFC_PARSE_API %(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;
+    virtual const IfcParse::type_declaration& declaration() const;
     static Type::Enum Class();
     explicit %(name)s (IfcEntityInstanceData* e);
     %(name)s (%(type)s v);
@@ -366,16 +370,17 @@ public:
 
 simpletype_impl_comment = "// Function implementations for %(name)s"
 simpletype_impl_argument_type = "if (i == 0) { return %(attr_type)s; } else { throw IfcParse::IfcAttributeOutOfRangeException(\"Argument index out of range\"); }"
-simpletype_impl_argument = "return entity->getArgument(i);"
+simpletype_impl_argument = "return data_->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           = "entity = new IfcEntityInstanceData(Class()); {IfcWrite::IfcWriteArgument* attr = new IfcWrite::IfcWriteArgument(); attr->set(v"           +"); entity->setArgument(0, attr);}"
-simpletype_impl_constructor_templated = "entity = new IfcEntityInstanceData(Class()); {IfcWrite::IfcWriteArgument* attr = new IfcWrite::IfcWriteArgument(); attr->set(v->generalize()); entity->setArgument(0, attr);}"
-simpletype_impl_cast = "return *entity->getArgument(0);"
-simpletype_impl_cast_templated = "IfcEntityList::ptr es = *entity->getArgument(0); return es->as<%(underlying_type)s>();"
+simpletype_impl_explicit_constructor = "data_ = e;"
+simpletype_impl_constructor           = "data_ = new IfcEntityInstanceData(Class()); {IfcWrite::IfcWriteArgument* attr = new IfcWrite::IfcWriteArgument(); attr->set(v"           +"); data_->setArgument(0, attr);}"
+simpletype_impl_constructor_templated = "data_ = new IfcEntityInstanceData(Class()); {IfcWrite::IfcWriteArgument* attr = new IfcWrite::IfcWriteArgument(); attr->set(v->generalize()); data_->setArgument(0, attr);}"
+simpletype_impl_cast = "return *data_->getArgument(0);"
+simpletype_impl_cast_templated = "IfcEntityList::ptr es = *data_->getArgument(0); return es->as<%(underlying_type)s>();"
+simpletype_impl_declaration = "return *%(class_name)s_type;"
     
 select = """%(documentation)s
 typedef IfcUtil::IfcBaseClass %(name)s;
@@ -392,13 +397,7 @@ IFC_PARSE_API %(name)s FromString(const std::string& s);
 entity = """%(documentation)s
 class IFC_PARSE_API %(name)s %(superclass)s{
 public:
-%(attributes)s    virtual unsigned int getArgumentCount() const { return %(argument_count)d; }
-    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const {%(argument_type_function_body)s}
-    virtual Type::Enum getArgumentEntity(unsigned int i) const {%(argument_entity_function_body)s}
-    virtual const char* getArgumentName(unsigned int i) const {%(argument_name_function_body)s}
-    virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
-%(inverse)s    bool is(Type::Enum v) const;
-    Type::Enum type() const;
+%(attributes)s    %(inverse)s    virtual const IfcParse::entity& declaration() const;
     static Type::Enum Class();
     %(name)s (IfcEntityInstanceData* e);
     %(name)s (%(constructor_arguments)s);
@@ -420,11 +419,12 @@ const char* %(name)s::ToString(%(name)s v) {
 """
 
 entity_implementation = """// Function implementations for %(name)s
-%(attributes)s%(inverse)sbool %(name)s::is(Type::Enum v) const { return v == Type::%(name)s%(parent_type_test)s; }
-Type::Enum %(name)s::type() const { return Type::%(name)s; }
+%(attributes)s
+%(inverse)s
+const IfcParse::entity& %(name)s::declaration() const { return *%(name)s_type; }
 Type::Enum %(name)s::Class() { return Type::%(name)s; }
-%(name)s::%(name)s(IfcEntityInstanceData* e) : %(superclass)s { if (!e) return; if (e->type() != Type::%(name)s) throw IfcException("Unable to find find keyword in schema"); entity = e; }
-%(name)s::%(name)s(%(constructor_arguments)s) : %(superclass)s {entity = new IfcEntityInstanceData(Class()); %(constructor_implementation)s }
+%(name)s::%(name)s(IfcEntityInstanceData* e) : %(superclass)s { if (!e) return; if (!e->is(Type::%(name)s)) throw IfcException("Unable to find find keyword in schema"); data_ = e; }
+%(name)s::%(name)s(%(constructor_arguments)s) : %(superclass)s {data_ = new IfcEntityInstanceData(Class()); %(constructor_implementation)s }
 """
 
 optional_attribute_description = "/// Whether the optional attribute %s is defined for this %s"
@@ -450,24 +450,24 @@ parent_type_stmt = '    if(v==%(name)s%(padding)s) { return %(parent)s; }'
 
 parent_type_test = " || %s::is(v)"
 
-optional_attr_stmt = "return !entity->getArgument(%(index)d)->isNull();"
+optional_attr_stmt = "return !data_->getArgument(%(index)d)->isNull();"
 
-get_attr_stmt = "return *entity->getArgument(%(index)d);"
-get_attr_stmt_enum = "return %(type)s::FromString(*entity->getArgument(%(index)d));"
-get_attr_stmt_entity = "return (%(type)s)((IfcUtil::IfcBaseClass*)(*entity->getArgument(%(index)d)));"
-get_attr_stmt_array = "IfcEntityList::ptr es = *entity->getArgument(%(index)d); return es->as<%(list_instance_type)s>();"
-get_attr_stmt_nested_array = "IfcEntityListList::ptr es = *entity->getArgument(%(index)d); return es->as<%(list_instance_type)s>();"
+get_attr_stmt = "return *data_->getArgument(%(index)d);"
+get_attr_stmt_enum = "return %(type)s::FromString(*data_->getArgument(%(index)d));"
+get_attr_stmt_entity = "return (%(type)s)((IfcUtil::IfcBaseClass*)(*data_->getArgument(%(index)d)));"
+get_attr_stmt_array = "IfcEntityList::ptr es = *data_->getArgument(%(index)d); return es->as<%(list_instance_type)s>();"
+get_attr_stmt_nested_array = "IfcEntityListList::ptr es = *data_->getArgument(%(index)d); return es->as<%(list_instance_type)s>();"
 
-get_inverse = "return entity->getInverse(Type::%(type)s, %(index)d)->as<%(type)s>();"
+get_inverse = "return data_->getInverse(Type::%(type)s, %(index)d)->as<%(type)s>();"
 
-set_attr_stmt       = "{IfcWrite::IfcWriteArgument* attr = new IfcWrite::IfcWriteArgument();attr->set(v"                                                                     +");entity->setArgument(%(index)d,attr);}"
-set_attr_stmt_enum  = "{IfcWrite::IfcWriteArgument* attr = new IfcWrite::IfcWriteArgument();attr->set(IfcWrite::IfcWriteArgument::EnumerationReference(v,%(type)s::ToString(v)));entity->setArgument(%(index)d,attr);}"
-set_attr_stmt_array = "{IfcWrite::IfcWriteArgument* attr = new IfcWrite::IfcWriteArgument();attr->set(v->generalize()"                                                       +");entity->setArgument(%(index)d,attr);}"
+set_attr_stmt       = "{IfcWrite::IfcWriteArgument* attr = new IfcWrite::IfcWriteArgument();attr->set(v"                                                                     +");data_->setArgument(%(index)d,attr);}"
+set_attr_stmt_enum  = "{IfcWrite::IfcWriteArgument* attr = new IfcWrite::IfcWriteArgument();attr->set(IfcWrite::IfcWriteArgument::EnumerationReference(v,%(type)s::ToString(v)));data_->setArgument(%(index)d,attr);}"
+set_attr_stmt_array = "{IfcWrite::IfcWriteArgument* attr = new IfcWrite::IfcWriteArgument();attr->set(v->generalize()"                                                       +");data_->setArgument(%(index)d,attr);}"
 
-constructor_stmt          = "{IfcWrite::IfcWriteArgument* attr = new IfcWrite::IfcWriteArgument();attr->set((%(name)s)"                                                                                +");entity->setArgument(%(index)d,attr);}"
-constructor_stmt_enum     = "{IfcWrite::IfcWriteArgument* attr = new IfcWrite::IfcWriteArgument();attr->set((IfcWrite::IfcWriteArgument::EnumerationReference(%(name)s,%(type)s::ToString(%(name)s)))" +");entity->setArgument(%(index)d,attr);}"
-constructor_stmt_array    = "{IfcWrite::IfcWriteArgument* attr = new IfcWrite::IfcWriteArgument();attr->set((%(name)s)->generalize()"                                                                  +");entity->setArgument(%(index)d,attr);}"
-constructor_stmt_derived  = "{IfcWrite::IfcWriteArgument* attr = new IfcWrite::IfcWriteArgument();attr->set(IfcWrite::IfcWriteArgument::Derived()"                                                     +");entity->setArgument(%(index)d,attr);}"
+constructor_stmt          = "{IfcWrite::IfcWriteArgument* attr = new IfcWrite::IfcWriteArgument();attr->set((%(name)s)"                                                                                +");data_->setArgument(%(index)d,attr);}"
+constructor_stmt_enum     = "{IfcWrite::IfcWriteArgument* attr = new IfcWrite::IfcWriteArgument();attr->set((IfcWrite::IfcWriteArgument::EnumerationReference(%(name)s,%(type)s::ToString(%(name)s)))" +");data_->setArgument(%(index)d,attr);}"
+constructor_stmt_array    = "{IfcWrite::IfcWriteArgument* attr = new IfcWrite::IfcWriteArgument();attr->set((%(name)s)->generalize()"                                                                  +");data_->setArgument(%(index)d,attr);}"
+constructor_stmt_derived  = "{IfcWrite::IfcWriteArgument* attr = new IfcWrite::IfcWriteArgument();attr->set(IfcWrite::IfcWriteArgument::Derived()"                                                     +");data_->setArgument(%(index)d,attr);}"
 
 constructor_stmt_optional = " if (%(name)s) {%(stmt)s } else { IfcWrite::IfcWriteArgument* attr = new IfcWrite::IfcWriteArgument(); attr->set(boost::blank()); entity->setArgument(%(index)d, attr); }"