more work on inverse attrs, code generation

stepcode · mpictor · Dec 26, 2014 · Oct 13, 2013 · Oct 13, 2013 · Oct 13, 2013
commit 98283dca3409e5098fa9926f2540761a077244db
diff --git a/src/cllazyfile/lazyRefs.h b/src/cllazyfile/lazyRefs.h
@@ -75,27 +75,29 @@ class lazyRefs {
             //3c - for each item in both _refMap and edL, add it to _referentInstances
             potentialReferentInsts( edL );
             //3d - load each inst
-            invAttrListNode * invNode = invAttr( _inst, ia /*, iaList*/ );
+            /*invAttrListNode * invNode*/
+            iAstruct * ias = invAttr( _inst, ia /*, iaList*/ );
             referentInstances_t::iterator insts = _referentInstances.begin();
             for( ; insts != _referentInstances.end(); ++insts ) {
-                loadInstIFFreferent( *insts, invNode );
+                loadInstIFFreferent( *insts, ias, ia );
             }
             //3f - cache edL - TODO
         }
 
-        void loadInstIFFreferent( instanceID inst, invAttrListNode * invNode ) {
+        void loadInstIFFreferent( instanceID inst, iAstruct * ias, const Inverse_attribute * ia ) {
             bool prevLoaded = _lim->isLoaded( inst );
             SDAI_Application_instance * rinst = _lim->loadInstance( inst );
-            bool ref = refersToCurrentInst( invNode->inverseADesc(), rinst );
+            bool ref = refersToCurrentInst( ia, rinst );
             if( ref ) {
-                if( invNode->isAggregate() ) {
-                    EntityAggregate * ea = ( ( invAttrListNodeA * )invNode )->getter()( _inst );
+                if( ia->inverted_attr_()->IsAggrType() ) {
+                    EntityAggregate * ea = ias->a;
+                    assert( ea && "is it possible for this to be null here? if so, must create & assign");
                     //TODO check if duplicate
                     ea->AddNode( new EntityNode( rinst ) );
                 } else {
-                    SDAI_Application_instance * ai = ( ( invAttrListNodeI * )invNode )->getter()( _inst );
+                    SDAI_Application_instance * ai = ias->i;
                     if( !ai ) {
-                        ( ( invAttrListNodeI * )invNode )->setter()( _inst, rinst );
+                        ias->i = rinst;
                     } else if( ai->GetFileId() != inst ) {
                         std::cerr << "ERROR: two instances (" << rinst << " and " << ai->GetFileId() << ") refer to inst ";
                         std::cerr << _inst->GetFileId() << ", but its inverse attribute is not an aggregation type!" << std::endl;
@@ -110,7 +112,7 @@ class lazyRefs {
         }
 
         ///3e - check if actually inverse ref
-        bool refersToCurrentInst( Inverse_attribute * ia, SDAI_Application_instance * referrer ) {
+        bool refersToCurrentInst( const Inverse_attribute * ia, SDAI_Application_instance * referrer ) {
             //find the attr
             int rindex = attrIndex( referrer, ia->_inverted_attr_id, ia->_inverted_entity_id );
             STEPattribute sa = referrer->attributes[ rindex ];
@@ -155,7 +157,7 @@ class lazyRefs {
             return -1;
         }
 
-        invAttrListNode * invAttr( SDAI_Application_instance * inst, const Inverse_attribute * ia /*, iaList_t & iaList */ ) {
+        iAstruct * invAttr( SDAI_Application_instance * inst, const Inverse_attribute * ia /*, iaList_t & iaList */ ) {
             /* looks for iAttrs in schemas/sdai_ap214e3/entity/SdaiGeometric_representation_context.cc, but the ctors don't populate it
              * shouldn't the parent class ctor populate it?
 ENTITY representation_context;
@@ -171,16 +173,22 @@ SUBTYPE OF (representation_context);
   coordinate_space_dimension : dimension_count;
 END_ENTITY; -- 10303-42: geometry_schema
              */
-            invAttrListNode * n = ( invAttrListNode * ) inst->iAttrs.GetHead();
-            while( n ) {
-                if( n->inverseADesc() == ia ) {
-                    return n;
+            SDAI_Application_instance::iAMap_t map = inst->getInvAttrs();
+            SDAI_Application_instance::iAMap_t::iterator iai = map.begin();
+            while( iai != map.end() ) {
+                if( iai->first == ia ) {
+                    return &( iai->second );
                 }
-                n = ( invAttrListNode * ) n->NextNode();
+                ++iai;
             }
-            std::cerr << "Error! inverse attr " << ia->Name() << " (" << ia << ") not found in iAttrs (";
-            std::cerr << ( void * )( & ( inst->iAttrs ) ) << ") - entity " << inst->eDesc->Name() << "." << std::endl;
-            return 0;
+            iai = map.begin();
+            //FIXME treat as unrecoverable?
+            std::cerr << "Error! inverse attr " << ia->Name() << " (" << ia << ") not found in iAMap for entity " << inst->getEDesc()->Name() << ". Map contents:" << std::endl;
+            for( ; iai != map.end(); ++iai ) {
+                std::cerr << iai->first->Name() << ": " << (void*)(iai->second.a) << ", ";
+            }
+            std::cerr << std::endl;
+            return NULL;
         }
 
         /**  3c. compare the type of each item in R with types in A
@@ -208,13 +216,13 @@ END_ENTITY; -- 10303-42: geometry_schema
             const Inverse_attribute * iAttr;
             for( ; !supersIter.empty(); ++supersIter ) {
                 //look at attrs of *si
-                InverseAItr iai( ( *supersIter )->InverseAttr() );
+                InverseAItr iai( &( ( *supersIter )->InverseAttr() ) );
                 while( 0 != ( iAttr = iai.NextInverse_attribute() ) ) {
                     iaList.insert( iAttr );
                 }
             }
             // look at our own attrs
-            InverseAItr invAttrIter( ed->InverseAttr() );
+            InverseAItr invAttrIter( &( ed->InverseAttr() ) );
             while( 0 != ( iAttr = invAttrIter.NextInverse_attribute() ) ) {
                 iaList.insert( iAttr );
             }
@@ -272,7 +280,7 @@ END_ENTITY; -- 10303-42: geometry_schema
 
 
             // 1. find inverse attrs with recursion
-            getInverseAttrs( ai->eDesc, _iaList );
+            getInverseAttrs( ai->getEDesc(), _iaList );
 
             //2. find reverse refs, map id to type (stop if there are no inverse attrs or no refs)
             if( _iaList.size() == 0 || !mapRefsToTypes() ) {

diff --git a/src/cllazyfile/sectionReader.cc b/src/cllazyfile/sectionReader.cc
@@ -308,7 +308,7 @@ SDAI_Application_instance * sectionReader::getRealInstance( const Registry * reg
         if( !comment.empty() ) {
             inst->AddP21Comment( comment );
         }
-        assert( inst->eDesc );
+        assert( inst->getEDesc() );
         _file.seekg( begin );
         findNormalString( "(" );
         _file.unget();

diff --git a/src/clstepcore/ExpDict.cc b/src/clstepcore/ExpDict.cc
@@ -554,9 +554,9 @@ const AttrDescriptor * AttrDescItr::NextAttrDesc() {
     return 0;
 }
 
-const Inverse_attribute * InverseAItr::NextInverse_attribute() {
+Inverse_attribute * InverseAItr::NextInverse_attribute() {
     if( cur ) {
-        const Inverse_attribute * ia = cur->Inverse_attr();
+        Inverse_attribute * ia = cur->Inverse_attr();
         cur = ( Inverse_attributeLinkNode * )( cur->NextNode() );
         return ia;
     }
@@ -811,6 +811,31 @@ EntityDescriptor::~EntityDescriptor() {
     delete _uniqueness_rules;
 }
 
+/** initialize inverse attrs
+ * call once per eDesc (once per EXPRESS entity type)
+ * must be called _after_ init_Sdai* functions for any ia->inverted_entity_id_'s
+ *
+ */
+void EntityDescriptor::InitIAttrs( entFinderFn entFinder ) {
+    InverseAItr iai( &( InverseAttr() ) );
+    Inverse_attribute * ia;
+    while( 0 != ( ia = iai.NextInverse_attribute() ) ) {
+        const AttrDescriptor * ad;
+        const char * aid = ia->inverted_attr_id_();
+        const char * eid = ia->inverted_entity_id_();
+        const EntityDescriptor * e = entFinder( eid );
+        AttrDescItr adl( e->ExplicitAttr() ); //TODO does this include inherited attrs? redefined? etc...
+        while( ( 0 != ( ad = adl.NextAttrDesc() ) ) && !strcmp( aid, ad->Name() ) ) {
+            // loop condition side effects do everything
+        }
+        if( !ad ) {
+            std::cerr << "Inverse attr " << ia->Name() << " for " << Name() << ": cannot find AttrDescriptor " << aid << " for entity " << eid << "." << std::endl;
+            //FIXME should we abort? or is there a sensible recovery path?
+        }
+        ia->inverted_attr_( ad );
+    }
+}
+
 const char * EntityDescriptor::GenerateExpress( std::string & buf ) const {
     std::string sstr;
     int count;
@@ -878,7 +903,7 @@ const char * EntityDescriptor::GenerateExpress( std::string & buf ) const {
     }
 /////////
 
-    InverseAItr iai( _inverseAttr );
+    InverseAItr iai( &_inverseAttr );
 
     iai.ResetItr();
     const Inverse_attribute * ia = iai.NextInverse_attribute();

diff --git a/src/clstepcore/ExpDict.h b/src/clstepcore/ExpDict.h
@@ -664,6 +664,7 @@ class SC_CORE_EXPORT Schema : public Dictionary_instance {
     protected:
         const char  * _name;
         EntityDescriptorList _entList; // list of entities in the schema
+        EntityDescriptorList _entsWithInverseAttrs;
         TypeDescriptorList _typeList; // list of types in the schema
         TypeDescriptorList _unnamed_typeList; // list of unnamed types in the schema (for cleanup)
         Interface_spec _interface; // list of USE and REF interfaces  (SDAI)
@@ -729,15 +730,31 @@ class SC_CORE_EXPORT Schema : public Dictionary_instance {
         EntityDescLinkNode * AddEntity( EntityDescriptor * ed ) {
             return _entList.AddNode( ed );
         }
+        /// must be called in addition to AddEntity()
+        EntityDescLinkNode * AddEntityWInverse( EntityDescriptor * ed ) {
+            return _entsWithInverseAttrs.AddNode( ed );
+        }
 
         TypeDescLinkNode * AddType( TypeDescriptor * td ) {
             return _typeList.AddNode( td );
         }
-
         TypeDescLinkNode * AddUnnamedType( TypeDescriptor * td ) {
             return _unnamed_typeList.AddNode( td );
         }
 
+        const EntityDescriptorList * Entities() const {
+            return & _entList;
+        }
+        const EntityDescriptorList * EntsWInverse() const {
+            return & _entsWithInverseAttrs;
+        }
+        const TypeDescriptorList * Types() const {
+            return & _typeList;
+        }
+        const TypeDescriptorList * UnnamedTypes() const {
+            return & _unnamed_typeList;
+        }
+
         // the whole schema
         void GenerateExpress( ostream & out ) const;
 
@@ -811,7 +828,7 @@ class SC_CORE_EXPORT Inverse_attributeLinkNode : public  SingleLinkNode {
         Inverse_attributeLinkNode();
         virtual ~Inverse_attributeLinkNode();
 
-        const Inverse_attribute * Inverse_attr() const {
+        Inverse_attribute * Inverse_attr() const {
             return _invAttr;
         }
         void Inverse_attr( Inverse_attribute * ia ) {
@@ -833,18 +850,21 @@ class SC_CORE_EXPORT Inverse_attributeList : public  SingleLinkList {
 
 class SC_CORE_EXPORT InverseAItr {
     protected:
-        const Inverse_attributeList & ial;
+        const Inverse_attributeList * ial;
         const Inverse_attributeLinkNode * cur;
 
     public:
-        InverseAItr( const Inverse_attributeList & iaList );
+        InverseAItr( const Inverse_attributeList * iaList );
         virtual ~InverseAItr();
 
-        void ResetItr() {
-            cur = ( Inverse_attributeLinkNode * )( ial.GetHead() );
+        void ResetItr( const Inverse_attributeList * iaList = 0 ) {
+            if( iaList ) {
+                ial = iaList;
+            }
+            cur = ( Inverse_attributeLinkNode * )( ial->GetHead() );
         }
 
-        const Inverse_attribute * NextInverse_attribute();
+        Inverse_attribute * NextInverse_attribute();
 };
 
 /**
@@ -1072,7 +1092,7 @@ class SC_CORE_EXPORT Inverse_attribute  :    public AttrDescriptor  {
         const char * _inverted_attr_id;
         const char * _inverted_entity_id;
     protected:
-        AttrDescriptor * _inverted_attr; // not implemented (?!)
+        const AttrDescriptor * _inverted_attr; // not implemented (?!) (perhaps this means "not used"?)
     public:
 
         Inverse_attribute(
@@ -1107,22 +1127,23 @@ class SC_CORE_EXPORT Inverse_attribute  :    public AttrDescriptor  {
             _inverted_entity_id = iei;
         }
 
-        /// FIXME not implemented (?!)
-        class AttrDescriptor * inverted_attr_() {
+        /// FIXME not implemented (?!) (perhaps this means "not set"?)
+        //set _inverted_attr in an extra init step in generated code? any other way to ensure pointers are valid?
+        const class AttrDescriptor * inverted_attr_() const {
                 return _inverted_attr;
         }
 
-        void inverted_attr_( AttrDescriptor * ia ) {
+        void inverted_attr_( const AttrDescriptor * ia ) {
             _inverted_attr = ia;
         }
 
         // below are obsolete (and not implemented anyway)
-        class AttrDescriptor * InverseAttribute() {
-                return _inverted_attr;
-        }
-        void InverseOf( AttrDescriptor * invAttr ) {
-            _inverted_attr = invAttr;
-        }
+//         class AttrDescriptor * InverseAttribute() {
+//                 return _inverted_attr;
+//         }
+//         void InverseOf( AttrDescriptor * invAttr ) {
+//             _inverted_attr = invAttr;
+//         }
 };
 
 /** \class SchRename
@@ -1473,9 +1494,14 @@ class SC_CORE_EXPORT EnumTypeDescriptor  :    public TypeDescriptor  {
  * will be building the same thing but using the new schema info.
  * nodes (i.e. EntityDesc nodes) for each entity.
  */
+
+class Registry;
+
 class SC_CORE_EXPORT EntityDescriptor  :    public TypeDescriptor  {
 
     protected:
+        //used in InitIAttrs so we don't have to #include registry.h
+
         SDAI_LOGICAL _abstractEntity;
         SDAI_LOGICAL _extMapping;
         // does external mapping have to be used to create an instance of
@@ -1487,6 +1513,7 @@ class SC_CORE_EXPORT EntityDescriptor  :    public TypeDescriptor  {
         Inverse_attributeList _inverseAttr;  // OPTIONAL
         std::string _supertype_stmt;
     public:
+        typedef const EntityDescriptor * (*entFinderFn)(const char *);
         Uniqueness_rule__set_var _uniqueness_rules; // initially a null pointer
 
         // pointer to a function that will create a new instance of a SDAI_Application_instance
@@ -1502,6 +1529,8 @@ class SC_CORE_EXPORT EntityDescriptor  :    public TypeDescriptor  {
 
         virtual ~EntityDescriptor();
 
+        void InitIAttrs( entFinderFn entFinder );
+
         const char * GenerateExpress( std::string & buf ) const;
 
         const char * QualifiedName( std::string & s ) const;

diff --git a/src/clstepcore/ExpDict.inline.cc b/src/clstepcore/ExpDict.inline.cc
@@ -162,9 +162,9 @@ Inverse_attributeLinkNode * Inverse_attributeList::AddNode( Inverse_attribute *
     return node;
 }
 
-InverseAItr::InverseAItr( const Inverse_attributeList & iaList )
+InverseAItr::InverseAItr( const Inverse_attributeList * iaList )
     : ial( iaList ) {
-    cur = ( Inverse_attributeLinkNode * )( ial.GetHead() );
+    cur = ( Inverse_attributeLinkNode * )( ial->GetHead() );
 }
 
 InverseAItr::~InverseAItr() {

diff --git a/src/clstepcore/Registry.inline.cc b/src/clstepcore/Registry.inline.cc
@@ -324,7 +324,7 @@ SDAI_Application_instance * Registry::ObjCreate( const char * nm, const char * s
             se->Error().severity( SEVERITY_WARNING );
             se->Error().UserMsg( "ENTITY requires external mapping" );
         }
-        se->eDesc = entd;
+        se->setEDesc( entd );
         return se;
     } else {
         return ENTITY_NULL;