Merge pull request #151 from swig-fortran/std-lib-enhance

Improve, fix, and extend standard library

Author: sethrj

Examples/test-suite/abstract_signature.i

@@ -2,6 +2,7 @@
 
 %warnfilter(SWIGWARN_RUBY_WRONG_NAME) abstract_foo;	// Ruby, wrong class name
 %warnfilter(SWIGWARN_RUBY_WRONG_NAME) abstract_bar;	// Ruby, wrong class name
+%warnfilter(SWIGWARN_LANG_OVERLOAD_SHADOW) meth; // Fortran prevents overloaded methods from overriding a base class non-overloaded method
 
 %inline %{ 
 class abstract_foo 

Examples/test-suite/constant_directive.i

@@ -4,6 +4,9 @@
 
 #ifdef SWIGOCAML
 %warnfilter(SWIGWARN_PARSE_KEYWORD) val;
+#elif SWIGFORTRAN
+// Can't natively wrap function pointers with nonnative return type
+%warnfilter(SWIGWARN_LANG_NATIVE_UNIMPL,SWIGWARN_TYPEMAP_UNDEF) TYPE1FPTR1_CONSTANT1;
 #endif
 
 %inline %{

Examples/test-suite/fortran/Makefile.in

@@ -52,7 +52,6 @@ FAILING_CPP_TESTS += \
 	smart_pointer_member \
 	smart_pointer_template_defaults_overload \
 	typedef_classforward_same_name \
-	li_std_map \
 	cpp11_result_of \
 	cpp11_rvalue_reference2 \
 	cpp11_rvalue_reference3 \

Examples/test-suite/fortran/li_std_map_runme.F90

@@ -0,0 +1,73 @@
+! File : li_std_map_runme.f90
+
+#include "fassert.h"
+
+program li_std_map_runme
+  use ISO_C_BINDING
+  implicit none
+
+  call test_map_int_int
+  call test_map_string_int
+contains
+
+subroutine test_map_int_int
+  use ISO_C_BINDING
+  ! Note that the test instantiates *multiset* as a set_int
+  use li_std_map, only : MapIntInt => IntIntMap
+  implicit none
+  type(MapIntInt) :: m
+  integer :: num_erased
+  logical :: inserted = .false.
+
+  m = MapIntInt()
+  ASSERT(m%empty())
+
+  call m%insert(10, 4)
+  call m%insert(3, 5, inserted)
+  ASSERT(inserted .eqv. .true.)
+  ASSERT(m%size() == 2)
+  ASSERT(m%count(3) == 1)
+  ASSERT(m%count(5) == 0)
+
+  ! Insertion of existing element will *not* replace value
+  call m%insert(3, 6, inserted)
+  ASSERT(inserted .eqv. .false.)
+  ASSERT(m%count(3) == 1)
+  ASSERT(m%size() == 2)
+  ASSERT(m%get(3) == 5)
+
+  ! Use "set" method to unconditionally assign
+  call m%set(3, 6)
+  ASSERT(m%get(3) == 6)
+
+  call m%erase(10)
+  ASSERT(m%size() == 1)
+  ASSERT(m%count(10) == 0)
+
+  call m%erase(3, num_erased)
+  ASSERT(num_erased == 1)
+  ASSERT(m%count(3) == 0)
+
+  call m%release()
+end subroutine
+
+subroutine test_map_string_int
+  use ISO_C_BINDING
+  use li_std_map, only : MapStringInt => StringIntMap
+  implicit none
+  type(MapStringInt) :: m
+
+  m = MapStringInt()
+  ASSERT(m%empty())
+
+  call m%insert("yoohoo", 10)
+  call m%insert("howdy", 5)
+  ASSERT(m%size() == 2)
+  ASSERT(m%count("yoohoo") == 1)
+  ASSERT(m%count("hiya") == 0)
+  ASSERT(m%get("yoohoo") == 10)
+  call m%release()
+end subroutine
+
+end program
+

Examples/test-suite/fortran/li_std_set_runme.F90

@@ -52,17 +52,20 @@ subroutine test_set_string
   use li_std_set, only : set_string
   implicit none
   type(set_string) :: s
+  logical :: inserted = .false.
 
   s = set_string()
   ASSERT(s%empty())
 
   call s%insert("yoohoo")
-  call s%insert("howdy")
+  call s%insert("howdy", inserted)
+  ASSERT(inserted .eqv. .true.)
   ASSERT(s%size() == 2)
   ASSERT(s%count("yoohoo") == 1)
   ASSERT(s%count("hiya") == 0)
 
-  call s%insert("howdy")
+  call s%insert("howdy", inserted)
+  ASSERT(inserted .eqv. .false.)
   ASSERT(s%count("howdy") == 1)
   ASSERT(s%size() == 2)
 

Examples/test-suite/fortran/li_std_string_runme.F90

@@ -0,0 +1,25 @@
+! File : li_std_string_runme.f90
+
+#include "fassert.h"
+
+program li_std_string_runme
+  use li_std_string
+  use ISO_C_BINDING
+  implicit none
+  character(kind=C_CHAR, len=*), parameter :: mystring = "howdy!"
+  character(kind=C_CHAR, len=:), allocatable :: actual
+  type(swigtype_p_std__string) :: anonymous_string
+
+  allocate(actual, source=test_value(mystring))
+  ASSERT(actual == mystring)
+  deallocate(actual)
+
+  actual = test_const_reference(mystring)
+  ASSERT(actual == mystring)
+  deallocate(actual)
+
+  call test_pointer(anonymous_string)
+
+  anonymous_string = test_pointer_out()
+end program
+

Examples/test-suite/fortran_ownership.i

@@ -76,3 +76,18 @@ void do_nothing(TemplTricky<int>) {};
 %}
 
 %template(TemplTrickyInt) myns::TemplTricky<int>;
+
+// Test autofree declaration *before* including std:string
+%fortran_autofree_rvalue(std::string)
+namespace std {
+class string {
+};
+}
+
+%include <std_string.i>
+
+%inline %{
+std::string str_value(std::string s) { return s; }
+const std::string& str_cref(const std::string& s) { return s; }
+std::string& str_ref(std::string& s) { return s; }
+%}

Lib/fortran/std_map.i

@@ -2,8 +2,60 @@
  * std_map.i
  * ------------------------------------------------------------------------- */
 
+%include "std_common.i"
+
 %{
 #include <map>
 %}
-#error "std::map support is not yet implemented"
 
+%define %swig_std_map(_Key, _Value, _Compare)
+
+public:
+  typedef size_t size_type;
+  typedef ptrdiff_t difference_type;
+  typedef _Key key_type;
+  typedef _Value mapped_type;
+  typedef std::pair<const _Key, _Value> value_type;
+  typedef value_type *pointer;
+  typedef const value_type *const_pointer;
+  typedef value_type &reference;
+  typedef const value_type &const_reference;
+
+  map();
+
+  // - Use native Fortran integers in proxy code
+  %apply int FORTRAN_INT {size_type};
+
+  bool empty() const;
+  size_type size() const;
+  void clear();
+
+  %fortransubroutine erase;
+
+  size_type erase(const key_type &x);
+  size_type count(const key_type &x) const;
+
+  %fortransubroutine insert;
+
+  %extend {
+    bool insert(const _Key& k, const _Value& v) {
+      std::pair<std::map<_Key, _Value, _Compare >::iterator, bool> result = $self->insert(std::pair<_Key, _Value>(k, v));
+      return result.second;
+    }
+
+    const _Value& get(const _Key& k) {
+      return (*$self)[k];
+    }
+    void set(const _Key& k, const _Value& v) {
+      (*$self)[k] = v;
+    }
+  }
+
+%enddef
+
+namespace std {
+template<class _Key, class _Value, class _Compare = std::less<_Key > >
+class map {
+  %swig_std_map(_Key, _Value, _Compare);
+};
+} // namespace std

Lib/fortran/std_multiset.i

@@ -7,10 +7,16 @@
 
 %include "std_set.i"
 
+%define %swig_std_multiset(_Key, _Compare, _Alloc)
+  %swig_std_setcommon(multiset, _Key, _Compare, _Alloc)
+
+  void insert(const_reference x);
+%enddef
+
 namespace std {
 template<class _Key, class _Compare = std::less<_Key>, class _Alloc = std::allocator<_Key> >
 class multiset {
-  SWIG_STD_SET_COMMON(multiset, _Key, _Compare, _Alloc)
+  %swig_std_multiset( _Key, _Compare, _Alloc)
 };
 } // end namespace std
 

Lib/fortran/std_set.i

@@ -8,7 +8,8 @@
 #include <set>
 %}
 
-%define SWIG_STD_SET_COMMON(CLASS, _Key, _Compare, _Alloc)
+// methods used by both set *and* multiset
+%define %swig_std_setcommon(CLASS, _Key, _Compare, _Alloc)
 
 public:
   // Typedefs
@@ -36,14 +37,25 @@ public:
 
   size_type erase(const key_type& x);
   size_type count(const key_type& x) const;
-  void insert(const_reference x);
+%enddef
+
+%define %swig_std_set(_Key, _Compare, _Alloc)
+  %swig_std_setcommon(set, _Key, _Compare, _Alloc)
+
+  %fortransubroutine insert;
 
+  %extend {
+    bool insert(const_reference x) {
+      std::pair<std::set<_Key, _Compare, _Alloc >::iterator, bool> result = $self->insert(x);
+      return result.second;
+    }
+  }
 %enddef
 
 namespace std {
 template<class _Key, class _Compare = std::less<_Key>, class _Alloc = std::allocator<_Key> >
 class set {
-  SWIG_STD_SET_COMMON(set, _Key, _Compare, _Alloc)
+  %swig_std_set(_Key, _Compare, _Alloc)
 };
 } // end namespace std