Add autofree_rvalue

Author: sethrj

include/flc.i

@@ -83,7 +83,7 @@ using std::size_t;
  * Linked into auto-generated file flibcpp_version.cpp
  ************************/
 
-%apply const char* { const char flibcpp_version[] };
+%apply char* { const char flibcpp_version[] };
 %fortranbindc flibcpp_version_major;
 %fortranbindc flibcpp_version_minor;
 %fortranbindc flibcpp_version_patch;

include/flc_random.i

@@ -27,6 +27,7 @@
 #endif
 
 %rename(Engine) std::SWIG_MERSENNE_TWISTER;
+%fortran_autofree_rvalue(std::SWIG_MERSENNE_TWISTER);
 
 namespace std {
 class SWIG_MERSENNE_TWISTER

include/flc_string.i

@@ -22,6 +22,9 @@
   $result = ($1 == std::string::npos ? 0 : $1 + 1);
 }
 
+// Automatically free temporary strings as appropriate
+%fortran_autofree_rvalue(std::string);
+
 namespace std {
 class string {
   public:

include/flc_vector.i

@@ -51,6 +51,9 @@
 %define %specialize_std_vector_pod(T)
 namespace std {
   template<> class vector<T> {
+    // Automatically free temporary vectors as appropriate
+    %fortran_autofree_rvalue(std::vector<T>);
+
     SWIG_STD_VECTOR_COMMON(T, const T&)
     SWIG_STD_VECTOR_REF(T)
     %extend {
@@ -72,6 +75,7 @@ namespace std {
 
 /* ------------------------------------------------------------------------- */
 
+%fortran_autofree_rvalue(std::vector<std::string>);
 %extend std::vector<std::string> {
   void set_ref(size_type index, std::string& str) {
     SWIG_check_range(index, $self->size(),

src/flc.f90

@@ -71,7 +71,7 @@ function swigc_flibcpp_version_get() &
 contains
  ! MODULE SUBPROGRAMS
 
-subroutine SWIGTM_fout_const_SS_char_Sm_(imout, fout)
+subroutine SWIGTM_fout_char_Sm_(imout, fout)
   use, intrinsic :: ISO_C_BINDING
   type(SwigArrayWrapper), intent(in) :: imout
   character(kind=C_CHAR, len=:), allocatable, intent(out) :: fout
@@ -91,7 +91,7 @@ function get_serr() &
 type(SwigArrayWrapper) :: fresult 
 
 fresult = swigc_get_serr()
-call SWIGTM_fout_const_SS_char_Sm_(fresult, swig_result)
+call SWIGTM_fout_char_Sm_(fresult, swig_result)
 if (.false.) call SWIG_free(fresult%data)
 end function
 
@@ -102,7 +102,7 @@ function get_flibcpp_version() &
 type(SwigArrayWrapper) :: fresult 
 
 fresult = swigc_flibcpp_version_get()
-call SWIGTM_fout_const_SS_char_Sm_(fresult, swig_result)
+call SWIGTM_fout_char_Sm_(fresult, swig_result)
 if (.false.) call SWIG_free(fresult%data)
 end function
 

src/flcFORTRAN_wrap.cxx

@@ -345,7 +345,7 @@ SWIGEXPORT SwigArrayWrapper _wrap_get_serr() {
   char *result = 0 ;
 
   result = (char *)flc_get_serr();
-  fresult.size = strlen(reinterpret_cast< const char* >(result));
+  fresult.size = strlen((char*)(result));
   fresult.data = const_cast< char * >(result);
   return fresult;
 }
@@ -356,7 +356,7 @@ SWIGEXPORT SwigArrayWrapper _wrap_flibcpp_version_get() {
   char *result = 0 ;
 
   result = (char *)(char *)flibcpp_version;
-  fresult.size = strlen(reinterpret_cast< const char* >(result));
+  fresult.size = strlen((char*)(result));
   fresult.data = const_cast< char * >(result);
   return fresult;
 }

src/flc_algorithmFORTRAN_wrap.cxx

@@ -216,12 +216,22 @@ enum SwigMemFlags {
 
 #define SWIG_check_nonnull(SWIG_CLASS_WRAPPER, TYPENAME, FNAME, FUNCNAME, RETURNNULL) \
   if (!(SWIG_CLASS_WRAPPER).cptr) { \
-    SWIG_exception_impl(FUNCNAME, SWIG_TypeError, \
+    SWIG_exception_impl(FUNCNAME, SWIG_NullReferenceError, \
                         "Cannot pass null " TYPENAME " (class " FNAME ") " \
                         "as a reference", RETURNNULL); \
   }
 
 
+namespace swig {
+enum AssignmentType {
+  ASSIGNMENT_DEFAULT,
+  ASSIGNMENT_NODESTRUCT,
+  ASSIGNMENT_SMARTPTR
+};
+}
+
+#define SWIGPOLICY_std_mt19937_64 swig::ASSIGNMENT_DEFAULT
+
 #include <stdexcept>
 
 
@@ -458,6 +468,123 @@ SWIGINTERN SwigClassWrapper SwigClassWrapper_uninitialized() {
     return result;
 }
 
+
+namespace swig {
+
+template<class T, AssignmentType A>
+struct DestructorPolicy {
+  static SwigClassWrapper destroy(SwigClassWrapper self) {
+    delete static_cast<T*>(self.cptr);
+    return SwigClassWrapper_uninitialized();
+  }
+};
+template<class T>
+struct DestructorPolicy<T, ASSIGNMENT_NODESTRUCT> {
+  static SwigClassWrapper destroy(SwigClassWrapper) {
+    SWIG_exception_impl("assignment", SWIG_TypeError, "Invalid assignment: class type has private destructor", return SwigClassWrapper_uninitialized());
+  }
+};
+}
+
+
+namespace swig {
+
+SWIGINTERN SwigClassWrapper capture(SwigClassWrapper other) {
+  other.cmemflags &= ~SWIG_MEM_RVALUE;
+  return other;
+}
+
+template<class T, AssignmentType A>
+struct AssignmentPolicy {
+  static SwigClassWrapper destroy(SwigClassWrapper self) {
+    return DestructorPolicy<T, A>::destroy(self);
+  }
+  static SwigClassWrapper alias(SwigClassWrapper other) {
+    SwigClassWrapper self = other;
+    self.cmemflags &= ~SWIG_MEM_OWN;
+    return self;
+  }
+  static SwigClassWrapper move_alias(SwigClassWrapper self, SwigClassWrapper other) {
+    if (self.cmemflags & SWIG_MEM_OWN) {
+      destroy(self);
+    }
+    return capture(other);
+  }
+  static SwigClassWrapper copy_alias(SwigClassWrapper self, SwigClassWrapper other) {
+    if (self.cmemflags & SWIG_MEM_OWN) {
+      destroy(self);
+    }
+    return capture(other);
+  }
+};
+
+template<class T>
+struct AssignmentPolicy<T, ASSIGNMENT_SMARTPTR> {
+  static SwigClassWrapper destroy(SwigClassWrapper self) {
+    return DestructorPolicy<T, ASSIGNMENT_SMARTPTR>::destroy(self);
+  }
+  static SwigClassWrapper alias(SwigClassWrapper other) {
+    SwigClassWrapper self;
+    self.cptr = new T(*static_cast<T*>(other.cptr));
+    self.cmemflags = other.cmemflags | SWIG_MEM_OWN;
+    return self;
+  }
+  static SwigClassWrapper move_alias(SwigClassWrapper self, SwigClassWrapper other) {
+    self = copy_alias(self, other);
+    self.cmemflags = other.cmemflags & ~SWIG_MEM_RVALUE;
+    destroy(other);
+    return self;
+  }
+  static SwigClassWrapper copy_alias(SwigClassWrapper self, SwigClassWrapper other) {
+    // LHS and RHS should both 'own' their shared pointers
+    T *pself = static_cast<T*>(self.cptr);
+    T *pother = static_cast<T*>(other.cptr);
+    *pself = *pother;
+    return self;
+  }
+};
+
+} // end namespace swig
+
+template<class T, swig::AssignmentType A>
+SWIGINTERN void SWIG_assign(SwigClassWrapper* self, SwigClassWrapper other) {
+  typedef swig::AssignmentPolicy<T, A> Policy_t;
+
+  if (self->cptr == NULL) {
+    /* LHS is unassigned */
+    if (other.cmemflags & SWIG_MEM_RVALUE) {
+      /* Capture pointer from RHS, clear 'moving' flag */
+      *self = swig::capture(other);
+    } else {
+      /* Aliasing another class; clear ownership or copy smart pointer */
+      *self = Policy_t::alias(other);
+    }
+  } else if (other.cptr == NULL) {
+    /* Replace LHS with a null pointer */
+    *self = Policy_t::destroy(*self);
+  } else if (self->cptr == other.cptr) {
+    /* Self-assignment: ignore */
+  } else if (other.cmemflags & SWIG_MEM_RVALUE) {
+    /* Transferred ownership from a variable that's about to be lost.
+     * Move-assign and delete the transient data */
+    *self = Policy_t::move_alias(*self, other);
+  } else {
+    /* RHS shouldn't be deleted, alias to LHS */
+    *self = Policy_t::copy_alias(*self, other);
+  }
+}
+
+template<class T, swig::AssignmentType A>
+SWIGINTERN void SWIG_free_rvalue(SwigClassWrapper other) {
+  typedef swig::AssignmentPolicy<T, A> Policy_t;
+  if (other.cmemflags & SWIG_MEM_RVALUE 
+      && other.cmemflags & SWIG_MEM_OWN) {
+    /* We own *and* are being passed an expiring value */
+    Policy_t::destroy(other);
+  }
+}
+
+
 extern "C" {
 SWIGEXPORT void _wrap_sort__SWIG_1(SwigArrayWrapper *farg1) {
   int32_t *arg1 = (int32_t *) 0 ;
@@ -1123,6 +1250,7 @@ SWIGEXPORT void _wrap_shuffle__SWIG_1(SwigClassWrapper *farg1, SwigArrayWrapper
   arg2 = (int32_t *)farg2->data;
   arg3 = farg2->size;
   shuffle< int32_t >(*arg1,arg2,arg3);
+  SWIG_free_rvalue< std::mt19937_64, SWIGPOLICY_std_mt19937_64 >(*farg1);
 }
 
 
@@ -1136,6 +1264,7 @@ SWIGEXPORT void _wrap_shuffle__SWIG_2(SwigClassWrapper *farg1, SwigArrayWrapper
   arg2 = (int64_t *)farg2->data;
   arg3 = farg2->size;
   shuffle< int64_t >(*arg1,arg2,arg3);
+  SWIG_free_rvalue< std::mt19937_64, SWIGPOLICY_std_mt19937_64 >(*farg1);
 }
 
 
@@ -1149,6 +1278,7 @@ SWIGEXPORT void _wrap_shuffle__SWIG_3(SwigClassWrapper *farg1, SwigArrayWrapper
   arg2 = (double *)farg2->data;
   arg3 = farg2->size;
   shuffle< double >(*arg1,arg2,arg3);
+  SWIG_free_rvalue< std::mt19937_64, SWIGPOLICY_std_mt19937_64 >(*farg1);
 }