Remove autofree-rvalue from strings and other classes (#19)

Author: sethrj

include/flc_map.i

@@ -21,9 +21,6 @@
  * String maps
  * ------------------------------------------------------------------------- */
 
-%fortran_autofree_rvalue(std::map<std::string, int>);
-%fortran_autofree_rvalue(std::map<std::string, std::string>);
-
 %include <std_string.i>
 %import "flc_string.i"
 %template(MapStringInt) std::map<std::string, int>;

include/flc_random.i

@@ -23,7 +23,6 @@
  * ------------------------------------------------------------------------- */
 
 %define %flc_random_engine(NAME, GENERATOR, RESULT_TYPE)
-%fortran_autofree_rvalue(std::GENERATOR);
 namespace std {
 
 %rename(NAME) GENERATOR;

include/flc_set.i

@@ -74,9 +74,6 @@
  */
 %define %specialize_std_set_pod(T)
 
-// Automatically free temporary sets as appropriate
-%fortran_autofree_rvalue(std::set<T>);
-
 namespace std {
   template<> class set<T> {
     %swig_std_set(T, std::less<T>, std::allocator<T>)
@@ -124,8 +121,6 @@ static bool flc_set_includes(const Set_t& left, const Set_t& right)
  * String sets
  * ------------------------------------------------------------------------- */
 
-%fortran_autofree_rvalue(std::set<std::string>);
-
 // Allow direct insertion of a wrapped std::string
 %extend std::set<std::string> {
   %apply SWIGTYPE& { const std::string& STR_CLASS };

include/flc_string.i

@@ -31,9 +31,6 @@
  * String class definition
  * ------------------------------------------------------------------------- */
 
-// Automatically free temporary strings as appropriate
-%fortran_autofree_rvalue(std::string);
-
 namespace std {
 class string {
   public:

include/flc_vector.i

@@ -58,9 +58,6 @@
  */
 %define %flc_template_std_vector_pod(NAME, T)
 
-// Automatically free temporary vectors as appropriate
-%fortran_autofree_rvalue(std::vector<T>);
-
 namespace std {
   template<> class vector<T> {
 
@@ -79,24 +76,28 @@ namespace std {
  * Numeric vectors
  * ------------------------------------------------------------------------- */
 
-%flc_template_std_vector_pod(VectorInt4, int32_t)
-%flc_template_std_vector_pod(VectorInt8,   int64_t)
-%flc_template_std_vector_pod(VectorReal8,  double)
+%flc_template_std_vector_pod(VectorInt4,  int32_t)
+%flc_template_std_vector_pod(VectorInt8,  int64_t)
+%flc_template_std_vector_pod(VectorReal8, double)
 
 /* -------------------------------------------------------------------------
  * String vectors
  * ------------------------------------------------------------------------- */
 
-%fortran_autofree_rvalue(std::vector<std::string>);
+%include <std_string.i>
+%import "flc_string.i"
+
+%apply SWIGTYPE& { const std::string& value };
+
 %extend std::vector<std::string> {
-  void set_ref(size_type index, std::string& str) {
+  void set_ref(size_type index, const std::string& value) {
     SWIG_check_range(index, $self->size(),
                      "std::vector<std::string>::set_ref",
                      return);
-    (*$self)[index] = str;
+    (*$self)[index] = value;
   }
 }
 
-%include <std_string.i>
-%import "flc_string.i"
 %template(VectorString) std::vector<std::string>;
+
+%clear const std::string& value;

src/flc_algorithmFORTRAN_wrap.cxx

@@ -221,15 +221,6 @@ enum SwigMemFlags {
                         "as a reference", RETURNNULL); \
   }
 
-
-namespace swig {
-enum AssignmentType {
-  ASSIGNMENT_DEFAULT,
-  ASSIGNMENT_NODESTRUCT,
-  ASSIGNMENT_SMARTPTR
-};
-}
-
 #define SWIGPOLICY_std_mt19937 swig::ASSIGNMENT_DEFAULT
 #define SWIGPOLICY_std_mt19937_64 swig::ASSIGNMENT_DEFAULT
 
@@ -475,123 +466,6 @@ 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 ;
@@ -1373,7 +1247,6 @@ 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, SWIGPOLICY_std_mt19937 >(*farg1);
 }
 
 
@@ -1387,7 +1260,6 @@ 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, SWIGPOLICY_std_mt19937 >(*farg1);
 }
 
 
@@ -1401,7 +1273,6 @@ 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, SWIGPOLICY_std_mt19937 >(*farg1);
 }
 
 
@@ -1415,7 +1286,6 @@ SWIGEXPORT void _wrap_shuffle__SWIG_4(SwigClassWrapper *farg1, SwigArrayWrapper
   arg2 = (void **)farg2->data;
   arg3 = farg2->size;
   shuffle< void * >(*arg1,arg2,arg3);
-  SWIG_free_rvalue< std::mt19937, SWIGPOLICY_std_mt19937 >(*farg1);
 }
 
 

src/flc_randomFORTRAN_wrap.cxx

@@ -636,7 +636,6 @@ SWIGEXPORT void _wrap_uniform_int_distribution__SWIG_1(int32_t const *farg1, int
   arg4 = (int32_t *)farg4->data;
   arg5 = farg4->size;
   uniform_int_distribution< int32_t,std::mt19937 >(arg1,arg2,*arg3,arg4,arg5);
-  SWIG_free_rvalue< std::mt19937, SWIGPOLICY_std_mt19937 >(*farg3);
 }
 
 
@@ -654,7 +653,6 @@ SWIGEXPORT void _wrap_uniform_int_distribution__SWIG_2(int64_t const *farg1, int
   arg4 = (int64_t *)farg4->data;
   arg5 = farg4->size;
   uniform_int_distribution< int64_t,std::mt19937 >(arg1,arg2,*arg3,arg4,arg5);
-  SWIG_free_rvalue< std::mt19937, SWIGPOLICY_std_mt19937 >(*farg3);
 }
 
 
@@ -672,7 +670,6 @@ SWIGEXPORT void _wrap_uniform_real_distribution(double const *farg1, double cons
   arg4 = (double *)farg4->data;
   arg5 = farg4->size;
   uniform_real_distribution< double,std::mt19937 >(arg1,arg2,*arg3,arg4,arg5);
-  SWIG_free_rvalue< std::mt19937, SWIGPOLICY_std_mt19937 >(*farg3);
 }
 
 
@@ -690,7 +687,6 @@ SWIGEXPORT void _wrap_normal_distribution(double const *farg1, double const *far
   arg4 = (double *)farg4->data;
   arg5 = farg4->size;
   normal_distribution< double,std::mt19937 >(arg1,arg2,*arg3,arg4,arg5);
-  SWIG_free_rvalue< std::mt19937, SWIGPOLICY_std_mt19937 >(*farg3);
 }
 
 
@@ -708,7 +704,6 @@ SWIGEXPORT void _wrap_discrete_distribution__SWIG_1(SwigArrayWrapper *farg1, Swi
   arg4 = (int32_t *)farg4->data;
   arg5 = farg4->size;
   discrete_distribution< int32_t,std::mt19937 >((double const *)arg1,arg2,*arg3,arg4,arg5);
-  SWIG_free_rvalue< std::mt19937, SWIGPOLICY_std_mt19937 >(*farg3);
 }
 
 
@@ -726,7 +721,6 @@ SWIGEXPORT void _wrap_discrete_distribution__SWIG_2(SwigArrayWrapper *farg1, Swi
   arg4 = (int64_t *)farg4->data;
   arg5 = farg4->size;
   discrete_distribution< int64_t,std::mt19937 >((double const *)arg1,arg2,*arg3,arg4,arg5);
-  SWIG_free_rvalue< std::mt19937, SWIGPOLICY_std_mt19937 >(*farg3);
 }