Change set algorithms to be member functions

Author: sethrj

doc/modules/set.rst

@@ -11,7 +11,7 @@ Set
 Sets are sorted containers of unique elements. The ``flc_set`` module
 defines sets of ``integer`` and of ``type(String)``.
 
-Common functionality
+Basic functionality
 ===================
 
 All set types support the following basic operations.
@@ -49,17 +49,42 @@ Here's an example of creating, modifying, and destroying a set::
    call s%release() ! Free memory
 
 Set operations
-==============
+--------------
+
+The Fortran ``Set`` classes have been extended to include several useful set
+algorithms. (In C++, these are implemented using the ``<algorithm>`` header and
+therefore should resemble the functions in
+:ref:`the flc_algorithm module <modules_algorithm_set_operations>`.
+
+All set operations take a single argument, another ``Set`` object, and do not
+modify either the original or the argument. All but the ``includes`` return
+newly allocated ``Set`` instances and do not modify the original sets.
+
+``difference``: :math:`A \setminus B`
+   Returns a new set with all elements from the original that are *not* present
+   in the other set.
+
+``intersection``: :math:`A \cap B`
+  Return all elements that are in both sets.
+
+``symmetric_difference``: :math:`(A \setminus B) \cup (B \setminus A)`
+  Return all elements that are in one set or the other but not both.
 
-Operations that take two sets are implemented as free functions.
+``union``: :math:`A \cup B`
+  Return all elements that are in either set.
 
+``includes``: :math:`A \supseteq B`
+  Return whether all elements of the other set are in the original set.
 
 Numeric sets
 ===============
 
 Unlike :ref:`vectors<modules_Vector>`, the ``flc_set`` module includes
 a single "native integer" numeric instantiations. The value type is
-``integer(C_INT)`` and is 64 bits on most modern systems.
+``integer(C_INT)`` and is 64 bits on most modern systems. Since the C++
+implementation of numerical sets is not very efficient, the assumption is that
+the ``set`` will be used in a non-numerically-intensive capacity where the
+default integer is the most appropriate option.
 
 Construct from an array
 -----------------------

include/flc_set.i

@@ -21,22 +21,28 @@
  * Macro definitions
  * ------------------------------------------------------------------------- */
 
-%define %flc_set_algorithm(FUNCNAME)
-%inline {
-template<class Set_t>
-static Set_t FUNCNAME(const Set_t& left, const Set_t& right)
-{
-    Set_t result;
-    std::FUNCNAME(left.begin(), left.end(),
-                  right.begin(), right.end(),
-                  std::inserter(result, result.end()));
-    return result;
-}
-}
-
-%template(FUNCNAME) FUNCNAME<std::set<int> >;
-%template(FUNCNAME) FUNCNAME<std::set<std::string> >;
+%define %flc_define_set_algorithm(FUNCNAME)
+  %insert("header") {
+  template<class Set_t>
+  static Set_t flc_##FUNCNAME(const Set_t& left, const Set_t& right)
+  {
+      Set_t result;
+      std::FUNCNAME(left.begin(), left.end(),
+                    right.begin(), right.end(),
+                    std::inserter(result, result.end()));
+      return result;
+  }
+  } // end %insert
+%enddef
 
+%define %flc_extend_set_algorithm(FUNCNAME, RETVAL, TYPE)
+  // The rename with the stringifying macro is necessary because 'union' is a
+  // keyword.
+  %rename(#FUNCNAME) std::set<TYPE>::set_##FUNCNAME;
+  %extend std::set<TYPE> {
+   RETVAL set_##FUNCNAME(const std::set<TYPE>& other)
+   { return flc_set_##FUNCNAME(*$self, other); }
+  } // end %extend
 %enddef
 
 %define %flc_extend_set_pod(CTYPE)
@@ -52,7 +58,6 @@ static Set_t FUNCNAME(const Set_t& left, const Set_t& right)
   void insert(const CTYPE* DATA, size_type SIZE) {
     $self->insert(DATA, DATA + SIZE);
   }
-
 %enddef
 
 /* ------------------------------------------------------------------------- */
@@ -83,10 +88,37 @@ namespace std {
 }
 %enddef
 
+/* -------------------------------------------------------------------------
+ * Algorithms
+ * ------------------------------------------------------------------------- */
+
+%flc_define_set_algorithm(set_difference)
+%flc_define_set_algorithm(set_intersection)
+%flc_define_set_algorithm(set_symmetric_difference)
+%flc_define_set_algorithm(set_union)
+
+%insert("header") %{
+template<class Set_t>
+static bool flc_set_includes(const Set_t& left, const Set_t& right)
+{
+    return std::includes(left.begin(), left.end(),
+                         right.begin(), right.end());
+}
+%}
+
+%define %flc_extend_algorithms(TYPE)
+  %flc_extend_set_algorithm(difference, std::set<TYPE >, TYPE)
+  %flc_extend_set_algorithm(intersection, std::set<TYPE >, TYPE)
+  %flc_extend_set_algorithm(symmetric_difference, std::set<TYPE >, TYPE)
+  %flc_extend_set_algorithm(union, std::set<TYPE >, TYPE)
+  %flc_extend_set_algorithm(includes, bool, TYPE)
+%enddef
+
 /* -------------------------------------------------------------------------
  * Numeric sets
  * ------------------------------------------------------------------------- */
 
+%flc_extend_algorithms(int)
 %specialize_std_set_pod(int)
 
 %template(SetInt) std::set<int>;
@@ -106,26 +138,5 @@ namespace std {
 
 %include <std_string.i>
 %import "flc_string.i"
+%flc_extend_algorithms(std::string)
 %template(SetString) std::set<std::string>;
-
-/* -------------------------------------------------------------------------
- * Algorithms
- * ------------------------------------------------------------------------- */
-
-%flc_set_algorithm(set_difference)
-%flc_set_algorithm(set_intersection)
-%flc_set_algorithm(set_symmetric_difference)
-%flc_set_algorithm(set_union)
-
-%inline %{
-template<class Set_t>
-static bool includes(const Set_t& left, const Set_t& right)
-{
-    return std::includes(left.begin(), left.end(),
-                         right.begin(), right.end());
-}
-%}
-
-%template(includes) includes<std::set<int> >;
-%template(includes) includes<std::set<std::string> >;
-