Changeset e318c0 in git for Singular

Timestamp:

Sep 5, 2012, 3:18:48 PM (12 years ago)

Author:

Alexander Dreyer <alexander.dreyer@…>

Branches:

(u'fieker-DuVal', '117eb8c30fc9e991c4decca4832b1d19036c4c65')(u'spielwiese', 'fc741b6502fd8a97288eaa3eba6e5220f3c3df87')

Children:

cda275f5c6745c233d1ee5261720c388c5286ec9

Parents:

a010d6eaa276986ef854adc014c99f570301d549

git-author:

Alexander Dreyer <alexander.dreyer@itwm.fraunhofer.de>2012-09-05 15:18:48+02:00

git-committer:

Oleksandr Motsak <motsak@mathematik.uni-kl.de>2012-09-05 15:52:17+02:00

Message:

Introducing weak reference for back-referenceing data

chg: more strict (added private+friend)

Location:

Singular

Files:

• countedref.cc (modified) (6 diffs)
• countedref.h (modified) (6 diffs)

Singular/countedref.cc

@@ -352 +352 @@
   public RefCounter {
   typedef CountedRefData self;
-  typedef CountedRefPtr<self*, false, true> self_ptr;
+  typedef CountedRefWeakPtr<self*> back_ptr;
   typedef RefCounter base;
 
   /// Generate object linked to other reference (e.g. for subscripts)
-  CountedRefData(leftv wrapped, self_ptr back):
-    base(), m_data(wrapped), m_ring(back->m_ring), m_back(back) {  }
-
-  /// @name  isallow copying to avoid inconsistence
+  CountedRefData(leftv wrapped, back_ptr back):
+    base(), m_data(wrapped), m_ring(back->m_ring), m_back(back) {
+  }
+
+  /// @name Disallow copying to avoid inconsistence
   //@{
   self& operator=(const self&);
   CountedRefData(const self&);
   //@}
+
 public:
   typedef LeftvDeep::copy_tag copy_tag;
 
   /// Fix smart pointer type to referenced data
-  typedef self_ptr ptr_type;
+  typedef back_ptr::ptr_type ptr_type;
 
   /// Fix smart pointer type to ring
@@ -386 +388 @@
 
   /// Destruct
-  ~CountedRefData() {  if (m_back)  m_data.clearid(root()); }
-
-  /// Generate 
-  ptr_type subscripted() {
-    return new self(m_data.idify(root()), 
-                    m_back? m_back: ptr_type(this));
-  }
-
+  ~CountedRefData() {
+    if (!m_back.unassigned()) {
+      if (m_back == this)
+        m_back.invalidate();
+      else
+        m_data.clearid(root()); 
+    }
+  }
+
+  /// Generate object for indexing
+  ptr_type subscripted() { return new self(m_data.idify(root()), weakref()); }
+
+  /// Gerenate  weak (but managed) reference to @c *this
+  back_ptr weakref() {
+    if (m_back.unassigned()) 
+      m_back = this;
+    return m_back;
+  }
   /// Replace with other Singular data
   self& operator=(leftv rhs) {
@@ -410 +422 @@
   BOOLEAN rering() {
     if (m_ring ^ m_data.ringed()) m_ring = (m_ring? NULL: currRing);
-    return (m_back && m_back->rering());
+    return (m_back && (m_back != this) && m_back->rering());
   }
 
@@ -418 +430 @@
   /// Check whether identifier became invalid
   BOOLEAN broken() const {
+    if (!m_back.unassigned() && !m_back) 
+      return complain("Back-reference broken");    
+
     if (m_ring) {
       if (m_ring != currRing) 
@@ -466 +481 @@
 
   /// Reference to actual object for indexed structures  
-  ptr_type m_back;
+  back_ptr m_back;
 };
 
@@ -492 +507 @@
 
   /// Fix smart pointer type to referenced data
-  typedef data_type::ptr_type data_ptr;
+  typedef CountedRefPtr<CountedRefData*> data_ptr;
 
   /// Check whether argument is already a reference type

Singular/countedref.h

@@ -26 +26 @@
  *
  * The template arguments, include the pointer type @c PtrType, and two
- * integral (bool) properties: use @c isWeak to disallow destruction
+ * integral (bool) properties: use @c Nondestructive to disallow destruction
  * and @c NeverNull to assume, that @c PtrType cannot be @c NULL.
  * Finally, @c CountType allows you to select a typ to represent the internal reference count.
@@ -34 +34 @@
  * In addition you must overload @c void CountedRefPtr_kill(PtrType) accordingly.
  **/
-template <class PtrType, bool isWeak = false, bool NeverNull = false, class CountType = short>
+template <class PtrType, bool Nondestructive = false, bool NeverNull = false,
+          class CountType = short>
 class CountedRefPtr {
   typedef CountedRefPtr self;
@@ -42 +43 @@
   typedef PtrType ptr_type;
   typedef CountType count_type;
-  enum { is_weak = isWeak, never_null = NeverNull };
+  enum { nondestructive = Nondestructive, never_null = NeverNull };
   //}
 
@@ -53 +54 @@
   /// Convert from compatible smart pointer
   template <bool Never>
-  CountedRefPtr(const CountedRefPtr<ptr_type, !is_weak, Never, count_type>& rhs):
+  CountedRefPtr(const CountedRefPtr<ptr_type, !nondestructive, Never, count_type>& rhs):
     m_ptr(rhs.m_ptr) { reclaim(); }
 
@@ -85 +86 @@
   //}
 
-  //{ @name Reference count interface
+  /// @name Reference count interface
+  //@{
   count_type count() const { return (*this? m_ptr->ref: 0); }
   void reclaim() { if (*this) ++m_ptr->ref; }
   void release() { 
-    if (*this && (--m_ptr->ref <= 0) && !is_weak)
+    if (*this && (--m_ptr->ref <= 0) && !nondestructive)
       CountedRefPtr_kill(m_ptr); 
   }
-  //}
+  //@}
 
 private:
@@ -127 +129 @@
   count_type ref;  // naming consistent with other classes
 };
-#if 0
-class CountedRefEnv {
-  typedef CountedRefEnv self;
-
-public:
-  static leftv idify(leftv head, idhdl* root) {
-    idhdl handle = newid(head, root);
-    leftv res = (leftv)omAlloc0(sizeof(*res));
-    res->data =(void*) handle;
-    res->rtyp = IDHDL;
-    return res;
-  }
-
-  static idhdl newid(leftv head, idhdl* root) {
-
-    static unsigned int counter = 0;
-    char* name = (char*) omAlloc0(512);
-    sprintf(name, " :%u:%p:_shared_: ", ++counter, head->data);
-    if ((*root) == NULL )
-      enterid(name, 0, head->rtyp, root, TRUE, FALSE);
+
+
+template <class PtrType>
+class CountedRefWeakPtr;
+
+template <class PtrType>
+class CountedRefIndirectPtr: 
+  public RefCounter {
+public:
+  friend class CountedRefWeakPtr<PtrType>;
+private:
+  CountedRefIndirectPtr(PtrType ptr): m_ptr(ptr) { }
+  CountedRefIndirectPtr& operator=(PtrType ptr) { m_ptr = ptr; return *this; }
+  PtrType m_ptr;
+};
+
+template <class PtrType> 
+inline void CountedRefPtr_kill(CountedRefIndirectPtr<PtrType>* pval) { delete pval; }
+
+template <class PtrType>
+class CountedRefWeakPtr {
+  typedef CountedRefWeakPtr self;
+
+public:
+
+  /// @name Name template arguments
+  //@{ Name template arguments
+  typedef PtrType ptr_type;
+  typedef CountedRefPtr<CountedRefIndirectPtr<ptr_type>*> ptrptr_type;
+  //@}
+
+  /// Construct unassigned weak reference
+  CountedRefWeakPtr(): m_indirect(NULL) { }
+
+  /// Convert from pointer
+  CountedRefWeakPtr(ptr_type ptr): m_indirect(new CountedRefIndirectPtr<ptr_type>(ptr)) { }
+
+  /// Construct copy
+  CountedRefWeakPtr(const self& rhs):  m_indirect(rhs.m_indirect) { }
+
+  /// Unlink one reference (handled by CountedRefPtr)
+  ~CountedRefWeakPtr() { }
+
+  /// Mark weak reference as invalid
+  void invalidate() {  *this = NULL; }
+
+  /// Test whether reference was never used
+  bool unassigned() const { return !m_indirect; }
+
+  /// Pointer-style interface
+  //@{
+  operator bool() const {  return operator->(); }
+  self& operator=(const self& rhs) { 
+    m_indirect = rhs;
+    return *this;
+  }
+  self& operator=(ptr_type ptr) {
+    if (!m_indirect) 
+      m_indirect = new CountedRefIndirectPtr<ptr_type>(ptr);
     else
-      *root = (*root)->set(name, 0, head->rtyp, TRUE);
-
-    IDDATA(*root) = (char*) head->data;
-    return *root;
-  }
-
-  static void clearid(idhdl handle, idhdl* root) {
-    IDDATA(handle)=NULL;
-    IDTYP(handle)=NONE;
-    killhdl2(handle, root, NULL);
-  }
-  static int& ref_id() {
-    static int g_ref_id = 0;
-    return g_ref_id;
-  }
-
-  static int& sh_id() {
-    static int g_sh_id = 0;
-    return g_sh_id;
-  }
-};
-#endif
-/// Overloading ring destruction
-inline void CountedRefPtr_kill(ring r) { rKill(r); }
-
+      m_indirect->m_ptr = ptr;
+    return *this;
+  }
+  bool operator==(ptr_type ptr) const { 
+    return m_indirect &&(m_indirect->m_ptr == ptr); 
+  }
+  bool operator!=(ptr_type rhs) const { return !operator==(rhs); }
+  const ptr_type operator->() const { return (m_indirect? m_indirect->m_ptr: NULL); }
+  ptr_type operator->() {   return (m_indirect? m_indirect->m_ptr:NULL); }
+  //@}
+
+private:
+  ptrptr_type m_indirect;
+};
+
+
+
+
+/** @class LeftvHelper
+ * This class implements some recurrent code sniplets to be used with 
+ * @c leftv and @c idhdl.implements a refernce counter which we can use
+ **/
 class LeftvHelper {
 public: