Changeset d919cd in git for Singular/countedref.cc

Timestamp:

Sep 2, 2012, 4:55:06 PM (12 years ago)

Author:

Alexander Dreyer <alexander.dreyer@…>

Branches:

(u'spielwiese', 'fe61d9c35bf7c61f2b6cbf1b56e25e2f08d536cc')

Children:

a010d6eaa276986ef854adc014c99f570301d549

Parents:

9373f05657970e6e7e18aac67a18d1245fb6bb4e

git-author:

Alexander Dreyer <alexander.dreyer@itwm.fraunhofer.de>2012-09-02 16:55:06+02:00

git-committer:

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

Message:

new added some comments to developer's documentation, and documented system commands

File:

• Singular/countedref.cc (modified) (19 diffs)

Singular/countedref.cc

@@ -259 +259 @@
 
 public:
+  struct copy_tag {};
   LeftvDeep(): m_data(allocate()) {}
   LeftvDeep(leftv data): m_data(cpy(data)) { 
@@ -265 +266 @@
   }
 
-  LeftvDeep(leftv data,int,int): m_data(allocate()) {  m_data->Copy(data);  }
+  LeftvDeep(leftv data, copy_tag): m_data(allocate()) {  m_data->Copy(data);  }
 
   ~LeftvDeep() { m_data->CleanUp(); }
@@ -346 +347 @@
   public RefCounter {
   typedef CountedRefData self;
+  typedef CountedRefPtr<self*, false, true> self_ptr;
   typedef RefCounter base;
 
-  /// Subscripted object
-  CountedRefData(leftv wrapped, CountedRefPtr<self*> back):
+  /// 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) {  }
 
-  /// Disallow copying to avoid inconsistence
+  /// @name  isallow copying to avoid inconsistence
   //@{
   self& operator=(const self&);
@@ -358 +360 @@
   //@}
 public:
+  typedef LeftvDeep::copy_tag copy_tag;
+
+  /// Fix smart pointer type to referenced data
+  typedef self_ptr ptr_type;
+
+  /// Fix smart pointer type to ring
+  typedef CountedRefPtr<ring, true> ring_ptr;
+
   /// Construct shared memory empty Singular object
   explicit CountedRefData():
     base(), m_data(), m_ring(), m_back() { }
 
-  /// Construct reference for Singular object
+  /// Reference Singular object
   explicit CountedRefData(leftv data):
     base(), m_data(data), m_ring(parent(data)), m_back() { }
 
-  CountedRefData(leftv data, BOOLEAN global, int):
-    base(), m_data(data, global,0), m_ring(parent(data)), m_back() { }
+  /// Construct reference for Singular object
+  CountedRefData(leftv data, copy_tag do_copy):
+    base(), m_data(data, do_copy), m_ring(parent(data)), m_back() { }
 
   /// Destruct
@@ -373 +384 @@
 
   /// Generate 
-  CountedRefPtr<self*> subscripted() {
+  ptr_type subscripted() {
     return new self(m_data.idify(root()), 
-                    m_back? m_back: CountedRefPtr<self*>(this));
+                    m_back? m_back: ptr_type(this));
   }
 
@@ -447 +458 @@
 
   /// Store namespace for ring-dependent objects
-  CountedRefPtr<ring, true> m_ring;
+  ring_ptr m_ring;
 
   /// Reference to actual object for indexed structures  
-  CountedRefPtr<self*> m_back;
+  ptr_type m_back;
 };
 
@@ -472 +483 @@
   typedef int id_type;
 
-  /// Name type for handling reference data
+  /// Name type for handling referenced data
   typedef CountedRefData data_type;
+
+  /// Fix smart pointer type to referenced data
+  typedef data_type::ptr_type data_ptr;
 
   /// Check whether argument is already a reference type
@@ -483 +497 @@
   }
 
-  /// Construct new reference from Singular data  
+  /// Reference given Singular data  
   explicit CountedRef(leftv arg):  m_data(new data_type(arg)) { }
 
 protected:
   /// Recover previously constructed reference
-  CountedRef(data_type* arg):  m_data(arg) { assume(arg); }
+  CountedRef(data_ptr arg):  m_data(arg) { assume(arg); }
 
 public:
@@ -503 +517 @@
     return m_data->assign(result,arg);
   }
-  BOOLEAN rering() { return m_data->rering(); }
 
   /// Extract (shallow) copy of stored data
@@ -514 +527 @@
   }
 
-  /// Construct reference data object from
+  /// Construct reference data object from *this
   BOOLEAN outcast(leftv res) {
     if (res->rtyp == IDHDL)
@@ -522 +535 @@
     return FALSE;
   }
+
+  /// Construct raw reference data
   data_type* outcast() { 
     m_data.reclaim();
@@ -541 +556 @@
   }
 
+  /// Check whether object in valid in current context
   BOOLEAN broken() {return m_data->broken(); }
+
+  /// Check whether (shared) data was initialized but not assigned yet.
+  BOOLEAN unassigned() const { return m_data->unassigned(); }
 
   /// Get number of references pointing here, too
@@ -547 +566 @@
 
   // Get internal indentifier
-  BOOLEAN hash(leftv res) { return construct(res, (long)(data_type*)m_data); }
+  BOOLEAN enumerate(leftv res) { return construct(res, (long)(data_type*)m_data); }
 
   /// Check for likewise identifiers
@@ -567 +586 @@
   BOOLEAN name(leftv res) { return construct(res, operator*()->Name()); }
 
-  /// Check whther argument is not defined yet
-  BOOLEAN undefined(leftv res) { return construct(res, operator*()->Typ() == NONE); }
-  BOOLEAN unassigned() const { return  m_data->unassigned(); }
   /// Recover the actual object from raw Singular data
   static self cast(void* data) {
@@ -589 +605 @@
   }
 
-protected:
   /// Construct integer value
   static BOOLEAN construct(leftv res, long data) {
@@ -603 +618 @@
     return FALSE;
   }
-
+  /// Construct void-style object
+  static BOOLEAN construct(leftv res) {
+    res->data = NULL;
+    res->rtyp = NONE;
+    return FALSE;
+  }
+
+
+protected:
   /// Store pointer to actual data
-  CountedRefPtr<data_type*> m_data;
+  data_ptr m_data;
 };
 
@@ -712 +735 @@
   typedef CountedRef base;
 
+  /// Reinterprete @c CountedRef as @c CountedRefShared
   CountedRefShared(const base& rhs):  base(rhs) { }
-  CountedRefShared(data_type* rhs):  base(rhs) { }
+
+  /// Genreate   
+  CountedRefShared(data_ptr rhs):  base(rhs) { }
 
 public:
+  /// Default constructor for initialized, but all-zero, shared data object
   CountedRefShared():  base(new data_type) { }
-  explicit CountedRefShared(leftv arg):  base(new data_type(arg, FALSE,0)) { }
-
-  /// Construct copy
+
+  /// Construct internal copy of Singular interpreter object
+  explicit CountedRefShared(leftv arg):  base(new data_type(arg, data_type::copy_tag())) { }
+
+  /// Construct new reference to internal data 
   CountedRefShared(const self& rhs): base(rhs) { }
 
+  /// Desctruct 
   ~CountedRefShared() { }
 
+  /// Change reference to shared data 
   self& operator=(const self& rhs) {
     return static_cast<self&>(base::operator=(rhs));
   }
 
+  /// Recovering outcasted @c CountedRefShared object from interpreter object
   static self cast(leftv arg) { return base::cast(arg); }
+
+  /// Recovering outcasted @c CountedRefShared object from raw data
   static self cast(void* arg) { return base::cast(arg); }
 
@@ -739 +773 @@
 };
 
+/// Blackbox support - generate initialized, but all-zero - shared data 
 void* countedref_InitShared(blackbox*)
 {
@@ -768 +803 @@
       leftv next = args->next;
       args->next = NULL;
-      CountedRef obj = CountedRef::cast(args);
+
       char* name = (next->Typ() == STRING_CMD? 
                     (char*) next->Data(): (char*)next->Name());
       next = next->next;
+
+      if (strcmp(name, "help") == 0) {
+        PrintS("system(<ref>, ...): extended functionality for reference/shared data <ref>\n");
+        PrintS("  system(<ref>, count)         - number of references pointing to <ref>\n");
+        PrintS("  system(<ref>, enumerate)     - unique number for identifying <ref>\n");
+        PrintS("  system(<ref>, undefined)     - checks whether <ref> had been assigned\n");
+        PrintS("  system(<ref>, \"help\")        - prints this information message\n");
+        PrintS("  system(<ref>, \"typeof\")      - actual type referenced by <ref>\n");
+        PrintS("  system(<ref1>, same, <ref2>) - tests for identic reference objects\n");
+        return CountedRef::construct(res);
+      }
+      if (strncmp(name, "undef", 5) == 0) {
+        return CountedRef::construct(res, args->Data()? 
+                          (CountedRef::cast(args).unassigned()? 1: 2): 0);
+      }
+
+      CountedRef obj = CountedRef::cast(args);
       if (next) {
         if (strcmp(name, "same") == 0) return obj.same(res, next);
-        if (strncmp(name, "like", 4) == 0) return obj.likewise(res, next);
+        // likewise may be hard to interprete, so we not not document it above
+        if (strncmp(name, "like", 4) == 0) return obj.likewise(res, next);  
       }
       if (strncmp(name, "count", 5) == 0) return obj.count(res);
-      if (strcmp(name, "hash") == 0) return obj.hash(res);
-      if (strcmp(name, "name") == 0) return obj.name(res);
-      if (strncmp(name, "type", 4) == 0) return obj.type(res);
-      if (strncmp(name, "undef", 5) == 0) return obj.undefined(res);
+      if (strncmp(name, "enum", 4) == 0) return obj.enumerate(res);
+      if (strcmp(name, "name") == 0) return obj.name(res); // undecumented
+      if (strncmp(name, "typ", 3) == 0) return obj.type(res);
     }
     return TRUE;