Resurrect ref counting code. Fixes crash, but test still fails

dcwhite · dcwhite · commit 41a0901b0375 · 2014-10-27T16:01:31.000-06:00
diff --git a/src/Core/Matlab/matfiledata.cc b/src/Core/Matlab/matfiledata.cc
@@ -60,26 +60,80 @@
 using namespace SCIRun::MatlabIO;
 
 matfiledata::matfiledata()
-    : m_(0), ptr_(0) 
+  : m_(0), ptr_(0) 
 {
-  m_.reset(new mxdata);
+  m_ = new mxdata;
+  m_->dataptr_ = 0; 
+  m_->owndata_ = false;
+  m_->bytesize_ = 0;
+  m_->type_ = miUNKNOWN;
+  m_->ref_ = 1; 
 }
- 
+
 matfiledata::matfiledata(matfiledata::mitype type)
-    : m_(0) , ptr_(0)
+  : m_(0) , ptr_(0)
 {
-  m_.reset(new mxdata);
+  m_ = new mxdata;
+  m_->dataptr_ = 0; 
+  m_->owndata_ = false;
+  m_->bytesize_ = 0;
   m_->type_ = type;
+  m_->ref_ = 1; 
+}			 
+
+matfiledata::~matfiledata()
+{
+  if (m_ != 0)
+  {
+    clearptr();
+  }
 }
-  	
+
 void matfiledata::clear()
 {
   if (m_ == 0) 
   {
     std::cerr << "internal error in clear()\n";
     throw internal_error();
   }
-  m_.reset(new mxdata);
+  if ((m_->dataptr_ != 0)&&(m_->owndata_ == true)) delete[] static_cast<char *>(m_->dataptr_);
+  m_->owndata_ = false;
+  m_->dataptr_ = 0;	
+  m_->bytesize_ = 0;	
+  m_->type_ = miUNKNOWN;
+}
+
+void matfiledata::clearptr()
+{
+  if (m_ == 0) return;
+  m_->ref_--;
+  if (m_->ref_ == 0)
+  {
+    clear();
+    delete m_;
+  }
+  m_ = 0;
+  ptr_ = 0;
+}
+
+matfiledata::matfiledata(const matfiledata &mfd)
+{
+  m_ = 0;
+  m_ = mfd.m_;
+  ptr_ = mfd.ptr_;
+  m_->ref_++;
+}
+
+matfiledata& matfiledata::operator= (const matfiledata &mfd)
+{
+  if (this != &mfd)
+  {
+    clearptr();
+    m_ = mfd.m_;
+    ptr_ = mfd.ptr_;
+    m_->ref_++;
+  }
+  return *this;
 }
 
 void matfiledata::newdatabuffer(int bytesize,mitype type)
diff --git a/src/Core/Matlab/matfiledata.h b/src/Core/Matlab/matfiledata.h
@@ -109,27 +109,30 @@ namespace SCIRun
 
       // structure definitions
     private:
-      struct mxdata
+      struct mxdata 
       {
-        mxdata() : dataptr_(0), owndata_(false), bytesize_(0), type_(miUNKNOWN) {}
-        //TODO DAN: fix this bad warning
-        ~mxdata() { if (owndata_) delete[] dataptr_; }
         void	*dataptr_;	// Store the data to put in the matfile
         bool	owndata_;   // Do we own the data
         int	bytesize_;	// Size of the data in bytes
         mitype	type_;		// The type of the data
-      };
+        int	ref_;		// reference counter
+      };  
 
       // data objects
-    private:
-      boost::shared_ptr<mxdata> m_;
+      mxdata *m_;
       void *ptr_;
+      void clearptr();
 
-      // functions
+      // functions  
     public:
       matfiledata();
+      ~matfiledata();
+
       explicit matfiledata(mitype type);
 
+      matfiledata(const matfiledata &m); // copy constructor
+      matfiledata& operator= (const matfiledata &m); // assignment
+
       // clear() will remove any databuffer and empty the object
       // After calling this function a new buffer can be created
       void clear();
diff --git a/src/Core/Matlab/matlabarray.cc b/src/Core/Matlab/matlabarray.cc
@@ -44,6 +44,70 @@
 
 using namespace SCIRun::MatlabIO;
 
+
+// matlabarray management functions
+// constructor/destructor
+// assignment/copy constructor
+// clear
+
+// constructor
+// creates on the place holder for the matlabarray
+matlabarray::matlabarray()
+  : m_(0)
+{ 
+}   
+
+// destructor
+matlabarray::~matlabarray()	
+{
+  if (m_ != 0) 
+  {	// delete the attached structure if necessary 
+    m_->ref_--;
+    if (m_->ref_ == 0) { delete m_; }
+    m_ = 0;	
+  }	
+}
+
+// copy constructor    
+matlabarray::matlabarray(const matlabarray &m)
+{    
+  m_ = 0;
+
+  // reference the same structure as the matlabarray we are copying
+  if (m.m_ != 0) 
+  {
+    m_ = m.m_; 
+    m_->ref_++;
+  } 
+}
+
+
+
+// assignment	
+matlabarray& matlabarray::operator= (const matlabarray &m) 
+{ // the same construction as the previous function is used
+  // to create a copy
+
+  // if m = m we have to do nothing
+  if (this != &m)
+  {
+    if (m_ != 0)
+    {	// delete the attached structure if necessary 
+      m_->ref_--;
+      if (m_->ref_ == 0) { delete m_; }
+      m_ = 0;	
+    }
+
+    if (m.m_ != 0) 
+    {
+      m_ = m.m_;
+      m_->ref_++;
+    }  
+  }
+
+  return *this;	
+}
+
 // clear and empty
 
 // Clear: this function is for clearing the contents of the matrix and dereferencing
@@ -53,9 +117,16 @@ using namespace SCIRun::MatlabIO;
 
 void matlabarray::clear()
 {
-	m_.reset();
+
+  if (m_ != 0) 
+  {	// delete the attached structure if necessary 
+
+    m_->ref_--;
+    if (m_->ref_ == 0) { delete m_; }
+    m_ = 0;	
+  }	
 }
-	
+
 // This function can be used to test whether the matrix contains any data
 // If not do not try to access the matrix components. This will result in
 // an internal_error exception
@@ -72,7 +143,8 @@ matlabarray matlabarray::clone() const
 	matlabarray ma;
 	if (isempty()) return(ma);
 	
-	ma.m_.reset(new mxarray);
+  ma.m_ = new mxarray;
+  ma.m_->ref_ = 1;
 	ma.m_->class_ = m_->class_;
 	ma.m_->type_ = m_->type_;
 	ma.m_->flags_ = m_->flags_;
@@ -689,7 +761,8 @@ void matlabarray::createdensearray(const std::vector<int> &dims,mitype type)
   
   clear(); // make sure there is no data
   
-  m_.reset(new mxarray);
+  m_ = new mxarray;
+  m_->ref_ = 1;
 
   m_->class_ = mlDENSE;
   m_->type_ = type; 
@@ -707,7 +780,8 @@ void matlabarray::createdensearray(int m,int n,mitype type)
   
   clear(); // make sure there is no data
   
-  m_.reset(new mxarray);
+  m_ = new mxarray;
+  m_->ref_ = 1;
 
   m_->class_ = mlDENSE;
   m_->type_ = type; 
@@ -722,7 +796,8 @@ void matlabarray::createsparsearray(const std::vector<int> &dims,mitype type)
 {
   clear(); // make sure there is no data
   
-  m_.reset(new mxarray);
+  m_ = new mxarray;
+  m_->ref_ = 1;
   m_->class_ = mlSPARSE;
   m_->type_ = type;  // need to add some type checking here
   m_->flags_ = 0;
@@ -738,7 +813,8 @@ void matlabarray::createsparsearray(int m,int n,mitype type)
 	
   clear(); // make sure there is no data
   
-  m_.reset(new mxarray);
+  m_ = new mxarray;
+  m_->ref_ = 1;
   m_->class_ = mlSPARSE;
   m_->type_ = type;  // need to add some type checking here
   m_->flags_ = 0;
@@ -753,7 +829,8 @@ void matlabarray::createcellarray(const std::vector<int> &dims)
 {
   clear(); // make sure there is no data
 
-  m_.reset(new mxarray);
+  m_ = new mxarray;
+  m_->ref_ = 1;
 
   m_->class_ = mlCELL;
   m_->type_ = miMATRIX;  // need to add some type checking here
@@ -777,7 +854,8 @@ void matlabarray::createstructarray(const std::vector<int> &dims, const std::vec
 {
   clear(); // make sure there is no data
 
-  m_.reset(new mxarray);
+  m_ = new mxarray;
+  m_->ref_ = 1;
   m_->class_ = mlSTRUCT;
   m_->type_ = miMATRIX;  // need to add some type checking here
   m_->flags_ = 0;
@@ -792,7 +870,8 @@ void matlabarray::createstructarray()
 {
   clear(); // make sure there is no data
 
-  m_.reset(new mxarray);
+  m_ = new mxarray;
+  m_->ref_ = 1;
   m_->class_ = mlSTRUCT;
   m_->type_ = miMATRIX;  // need to add some type checking here
   m_->flags_ = 0;
@@ -820,7 +899,8 @@ void matlabarray::createclassarray(const std::vector<int> &dims,const std::vecto
 {
   clear(); // make sure there is no data
 
-  m_.reset(new mxarray);
+  m_ = new mxarray;
+  m_->ref_ = 1;
   m_->class_ = mlOBJECT;
   m_->type_ = miMATRIX;  // need to add some type checking here
   m_->flags_ = 0;
@@ -841,7 +921,8 @@ void matlabarray::createstringarray(const std::string& str)
 {
   clear(); // make sure there is no data
   
-  m_.reset(new mxarray);
+  m_ = new mxarray;
+  m_->ref_ = 1;
   m_->class_ = mlSTRING; 
   m_->type_ = miUINT8;
   m_->flags_ = 0;
diff --git a/src/Core/Matlab/matlabarray.h b/src/Core/Matlab/matlabarray.h
@@ -102,6 +102,17 @@ class SCISHARE matlabarray : public matfilebase
   
   class mxarray {
   public:
+    int  ref_; // reference counter: matlabarray is just a pointer to
+    // this structure. By keeping the data and the pointer
+    // separate a pointer (matlabarray class) can be
+    // created to a subarray without having to copy this
+    // subclass. Since there can be multiple pointers to
+    // the subclasses the reference counter counts how
+    // many instances of a matlabarray class point to this
+    // one. Creating a new matlabarray class this counter
+    // is increased and deleting the matlabarray class
+    // will decrease the pointer. When ref_ hits zero the
+    // structure is deleted.
     // matrix class information
                             
     mlclass class_;      // type of the array                    
@@ -143,7 +154,7 @@ class SCISHARE matlabarray : public matfilebase
   // delete them all. This behavior is circumvented by only storing a
   // pointer to the real object.
   
-  boost::shared_ptr<mxarray> m_; 
+  mxarray* m_; 
   
   // raw access for friend classes to the data containers. These
   // functions make a copy of the container handle and will allow
@@ -169,7 +180,11 @@ class SCISHARE matlabarray : public matfilebase
   // Set the type of the data in the Matlab array
   void settype(mitype type);
   
-  // functions to maintain the matlabarray
+  // function to create, copy, and destroy the object
+  matlabarray();  // constructor of an empty matrix
+  ~matlabarray();  // destructor
+  matlabarray(const matlabarray &m); // copy constructor
+  matlabarray& operator= (const matlabarray &m); // assignment
   
   // clear and empty
   void clear();    // empty matrix (no data stored at all)
