Changes in src/Patterns/ObservedIterator.hpp [f2bb0f:8774c5]

File:

• src/Patterns/ObservedIterator.hpp (modified) (5 diffs)

src/Patterns/ObservedIterator.hpp

@@ -36 +36 @@
 
   ObservedIterator(_Iter iter,Observable *obs) :
-    iter(iter)
-  {
-    // for this we actually get a lock on the heap,
-    // so we can copy ourselves
-    protector = new Observable::_Observable_protector(obs);
-  }
+    iter(iter),
+    collection(obs),
+    protector(0)
+  {}
 
   ObservedIterator(const ObservedIterator &dest) :
-    iter(dest.iter)
-  {
-    protector = new Observable::_Observable_protector(*dest.protector);
-  }
+    iter(dest.iter),
+    collection(dest.collection),
+    protector(dest.copyLock())
+  {}
 
   ~ObservedIterator(){
@@ -58 +56 @@
     if(&dest !=this){
       // get the new lock first, in case the two locks point to the same observable
-      Observable::_Observable_protector *newLock = new Observable::_Observable_protector(*dest.protector);
-      delete protector;
+      Observable::_Observable_protector *newLock = dest.copyLock();
+      if(protector)
+        delete protector;
       protector = newLock;
       // After the new lock is aquired we can safely set the iterator
       iter = dest.iter;
+      // we need to know the collection, in case we still have to set the lock
+      collection = dest.collection;
     }
     return *this;
@@ -83 +84 @@
   {
     --iter;
+    return *this;
   }
 
@@ -101 +103 @@
 
   value_type operator*(){
+    // access is requested... time to get the lock
+    acquireLock();
     return (*iter);
+  }
+
+  value_type *operator->(){
+    acquireLock();
+    return &(*iter);
   }
 
@@ -111 +120 @@
 
 private:
+
+  /**
+   * gets the lock for the collection when needed
+   *
+   * The lock is only acquired when the first change is done, so we can be free to do
+   * anything with the iterator before that. I.e. step forward, turn into a const_iterator
+   * etc.
+   */
+  void acquireLock(){
+    if(!protector)
+      protector = new Observable::_Observable_protector(collection);
+  }
+
+  Observable::_Observable_protector *copyLock() const{
+    // we only copy if we actually carry a lock
+    if(protector){
+      return new Observable::_Observable_protector(*protector);
+    }
+    else{
+      return 0;
+    }
+  }
+
   _Iter iter;
+  Observable *collection;
   Observable::_Observable_protector *protector;
 };