Merge pull request #144 from swig-fortran/std-set

Add `set`, `multiset`, and test

Author: sethrj

Doc/Manual/src/Fortran.md

@@ -850,10 +850,14 @@ subroutine mysub(x, y, swig_result)
   integer(C_INT), intent(out), optional :: swig_result
 end subroutine
 ```
-
 The resulting subroutine can be overloaded with other C++ void-returning
 functions.
 
+A common use case of `%fortransubroutine` is for C functions that return error
+codes or other noncritical information such as the number of items deleted. C++
+users should know that a `function` in Fortran is a stronger version of a
+`[[nodiscard]]`-marked function (since C++17): ignoring the return value is an
+error.
 
 ## Global variables
 

Examples/test-suite/fortran/Makefile.in

@@ -28,6 +28,7 @@ CPP_TEST_CASES = \
 	fortran_openacc \
 	fortran_overloads \
 	fortran_subroutine \
+	li_std_set \
 
 C_TEST_CASES = \
 	fortran_array_typemap \

Examples/test-suite/fortran/li_std_set_runme.F90

@@ -0,0 +1,80 @@
+! File : li_std_set_runme.f90
+
+#include "fassert.h"
+
+program li_std_set_runme
+  use ISO_C_BINDING
+  implicit none
+
+  call test_set_string
+  call test_multiset_int
+contains
+
+subroutine test_multiset_int
+  use ISO_C_BINDING
+  ! Note that the test instantiates *multiset* as a set_int
+  use li_std_set, only : multiset_int => set_int
+  implicit none
+  type(multiset_int) :: s
+  integer(c_size_t) :: num_erased
+
+  s = multiset_int()
+  ASSERT(s%empty())
+
+  call s%insert(10)
+  call s%insert(3)
+  ASSERT(s%size() == 2)
+  ASSERT(s%count(3) == 1)
+  ASSERT(s%count(5) == 0)
+
+  ! Duplicate elements allowed in multiset
+  call s%insert(3)
+  ASSERT(s%count(3) == 2)
+  ASSERT(s%size() == 3)
+
+  call s%erase(10)
+  ASSERT(s%size() == 2)
+  ASSERT(s%count(10) == 0)
+
+  call s%erase(3, num_erased)
+  ASSERT(num_erased == 2)
+  ASSERT(s%count(3) == 0)
+
+  call s%insert(1)
+  call s%clear()
+  ASSERT(s%empty())
+
+  call s%release()
+end subroutine
+
+subroutine test_set_string
+  use ISO_C_BINDING
+  use li_std_set, only : set_string
+  implicit none
+  type(set_string) :: s
+
+  s = set_string()
+  ASSERT(s%empty())
+
+  call s%insert("yoohoo")
+  call s%insert("howdy")
+  ASSERT(s%size() == 2)
+  ASSERT(s%count("yoohoo") == 1)
+  ASSERT(s%count("hiya") == 0)
+
+  call s%insert("howdy")
+  ASSERT(s%count("howdy") == 1)
+  ASSERT(s%size() == 2)
+
+  call s%erase("yoohoo")
+  ASSERT(s%size() == 1)
+  ASSERT(s%count("yoohoo") == 0)
+
+  call s%clear()
+  ASSERT(s%empty())
+
+  call s%release()
+end subroutine
+
+end program
+

Examples/test-suite/li_std_set.i

@@ -1,5 +1,5 @@
 /*
- * a test of set containers. 
+ * a test of set containers.
  * Languages should define swig::LANGUAGE_OBJ to be
  * an entity of their native pointer type which can be
  * included in a STL container.
@@ -26,9 +26,9 @@
 
 
 #if defined(SWIGRUBY)
-%template(LanguageSet) std::set<swig::LANGUAGE_OBJ>; 
+%template(LanguageSet) std::set<swig::LANGUAGE_OBJ>;
 #endif
 
 #if defined(SWIGPYTHON)
-%template(pyset) std::set<swig::SwigPtr_PyObject>; 
+%template(pyset) std::set<swig::SwigPtr_PyObject>;
 #endif

Lib/fortran/std_multiset.i

@@ -0,0 +1,40 @@
+/* -------------------------------------------------------------------------
+ * std_multiset.i
+ *
+ * Note: multiset interface is identical to std::set. It simply allows multiple
+ * keys.
+ * ------------------------------------------------------------------------- */
+
+%{
+#include <set>
+%}
+
+%fortransubroutine std::multiset::erase;
+
+namespace std {
+
+template<class _Key, class _Compare = std::less<_Key>, class _Alloc = std::allocator<_Key> >
+class multiset {
+public:
+  typedef _Key value_type;
+  typedef _Key key_type;
+  typedef std::size_t size_type;
+  typedef ptrdiff_t difference_type;
+  typedef value_type *pointer;
+  typedef const value_type *const_pointer;
+  typedef value_type &reference;
+  typedef const value_type &const_reference;
+  typedef _Alloc allocator_type;
+
+public:
+  set();
+
+  bool empty() const;
+  size_type size() const;
+  void clear();
+  size_type erase(const key_type& x);
+  size_type count(const key_type& x) const;
+  void insert(const_reference x);
+};
+} // namespace std
+

Lib/fortran/std_set.i

@@ -6,13 +6,17 @@
 #include <set>
 %}
 
-template<class _Key, class _Compare = std::less<_Key>, class _Alloc = allocator<_Key> >
+%fortransubroutine std::set::erase;
+
+namespace std {
+
+template<class _Key, class _Compare = std::less<_Key>, class _Alloc = std::allocator<_Key> >
 class set {
 public:
-  typedef std::size_t size_type;
-  typedef ptrdiff_t difference_type;
   typedef _Key value_type;
   typedef _Key key_type;
+  typedef std::size_t size_type;
+  typedef ptrdiff_t difference_type;
   typedef value_type *pointer;
   typedef const value_type *const_pointer;
   typedef value_type &reference;
@@ -25,9 +29,9 @@ public:
   bool empty() const;
   size_type size() const;
   void clear();
-  size_type erase(const key_type &x);
-  size_type count(const key_type &x) const;
+  size_type erase(const key_type& x);
+  size_type count(const key_type& x) const;
+  void insert(const_reference x);
 };
 
-
-
+} // namespace std