Wt

Consider the following pseudo example:

// construct Wt::Dbo::Session
// construct Wt::Dbo::Transaction

// load a Wt::Dbo::ptr from database

// destruct/commit the transaction

// modify the Wt::Dbo::ptr object => adds the object to Session::dirtyObjects_

// destruct the Wt::Dbo::Session => calls decRef on all dirtyObjects_ untill they are really destructed (although a Wt::Dbo::ptr still exists), in ~MetaDbo decRef will be called on a being destructed object.

// destruct the Wt::Dbo::ptr object => will call decRef on an already destructed object (see previous step)

Note that this problem may occur especially in case of manual flushing.

Possible solution:

Change the ~Session from

while (!dirtyObjects_->empty()) {
  MetaDboBase *b = *dirtyObjects_->begin();
  b->decRef();
}

to

while (!dirtyObjects_->empty()) {
  MetaDboBase *b = *dirtyObjects_->begin();
  discardChanges(b);
}

Possible solution v2:

Session.C:

Session::~Session()
{
  if (!dirtyObjects_->empty()) {
    LOG_WARN("Session exiting with " << dirtyObjects_->size() << " dirty objects");
  }

-  while (!dirtyObjects_->empty()) {
-    MetaDboBase *b = *dirtyObjects_->begin();
-    b->decRef();
-  }
-
-  dirtyObjects_->clear();
-  delete dirtyObjects_;

 for (ClassRegistry::iterator i = classRegistry_.begin();
      i != classRegistry_.end(); ++i)
   delete i->second;
+
+  delete dirtyObjects_; // dirtyObjects_ will be empty by now due to delete i->second (which calls rereadAll())
}

Session_impl.h:

template <class C>
Session::Mapping<C>::~Mapping()
{
+  rereadAll();
   for (typename Registry::iterator i = registry_.begin();
       i != registry_.end(); ++i) {
     i->second->setState(MetaDboBase::Orphaned);
   }
 }

Advantage of this solution is that all circular references between Wt::Dbo::ptr (in case Wt::Dbo::weak_ptr is not sufficiently/correctly used) are cleaned up at session destruction at least. This could for ex occur in case of the following situation of three classes refencing to each other using one-to-one are one-to-many relations:

a  <- b <-
|        |
-> c ----|

Disadvantage is that rereadAll introduces a copy of the registry_ array. However, this array should be small (or empty) during Session destruction.

Extra: Alternative implementation of rereadAll without copying array

To overcome the disadvantage of solution 2, rereadAll could be rewritten without copying the whole registry_ array.

template <class C>  
void Session::Mapping<C>::rereadAll() 
{
  if (registry_.empty())
    return;

  typename Registry::iterator i = registry_.begin();
  ptr<C> previous = i->second;
  for (++i; i != registry_.end(); previous = i->second, ++i)
    previous.reread();

  previous.reread();
}

Note that it is safe to reread the previous item as std::map::erase only invalidates the iterators pointing to the item being erased: References and iterators to the erased elements are invalidated. Other references and iterators are not affected.