[lmi-commits] [4947] Improve discrimination among containers

[Greg Chicares]

Revision: 4947
          http://svn.sv.gnu.org/viewvc/?view=rev&root=lmi&revision=4947
Author:   chicares
Date:     2010-05-13 22:40:50 +0000 (Thu, 13 May 2010)
Log Message:
-----------
Improve discrimination among containers

Modified Paths:
--------------
    lmi/trunk/ChangeLog
    lmi/trunk/contains.hpp
    lmi/trunk/contains_test.cpp

Modified: lmi/trunk/ChangeLog
===================================================================
--- lmi/trunk/ChangeLog 2010-05-13 01:09:42 UTC (rev 4946)
+++ lmi/trunk/ChangeLog 2010-05-13 22:40:50 UTC (rev 4947)
@@ -25733,3 +25733,9 @@
 See:
   http://lists.nongnu.org/archive/html/lmi/2010-05/msg00008.html
 
+20100513T2240Z <address@hidden> [706]
+
+  contains.hpp
+  contains_test.cpp
+Improve discrimination among containers.
+

Modified: lmi/trunk/contains.hpp
===================================================================
--- lmi/trunk/contains.hpp      2010-05-13 01:09:42 UTC (rev 4946)
+++ lmi/trunk/contains.hpp      2010-05-13 22:40:50 UTC (rev 4947)
@@ -26,6 +26,8 @@
 
 #include "config.hpp"
 
+#include <boost/utility/enable_if.hpp>
+
 #include <algorithm> // std::find()
 
 #if defined __BORLANDC__ || defined __COMO_VERSION__ && __COMO_VERSION__ <= 
4303
@@ -65,15 +67,19 @@
 
 /// Ascertain whether a "container" includes a given element.
 ///
-/// Here, consider std::basic_string is considered a "container",
+/// Here, std::basic_string is considered a "container", this:
 ///   http://www.comeaucomputing.com/iso/lwg-active.html#718
 ///   "basic_string is not a sequence"
 ///  notwithstanding.
 ///
-/// This overload is for "containers" that aren't handled specially.
+/// This overload is for "containers" that have no find() member.
 
 template<typename T>
-bool contains(T const& t, typename T::value_type const& element)
+bool contains
+    (T const& t
+    ,typename T::value_type const& element
+    ,typename boost::disable_if<has_member_find<T> >::type* = 0
+    )
 {
     return t.end() != std::find(t.begin(), t.end(), element);
 }
@@ -85,7 +91,11 @@
 /// This overload is for std::basic_string::find(std::basic_string).
 
 template<typename T>
-bool contains(T const& t, T const& element, typename T::traits_type::char_type 
const* = 0)
+bool contains
+    (T const& t
+    ,T const& element
+    ,typename T::traits_type::char_type const* = 0
+    )
 {
     return T::npos != t.find(element);
 }
@@ -97,7 +107,10 @@
 /// This overload is for std::basic_string::find(traits_type::char_type 
const*).
 
 template<typename T>
-bool contains(T const& t, typename T::traits_type::char_type const* element)
+bool contains
+    (T const& t
+    ,typename T::traits_type::char_type const* element
+    )
 {
     return T::npos != t.find(element);
 }
@@ -107,7 +120,10 @@
 /// If T has 'key_type', assume it behaves like an associative container.
 
 template<typename T>
-bool contains(T const& t, typename T::key_type const& element)
+bool contains
+    (T const& t
+    ,typename T::key_type const& element
+    )
 {
     return t.end() != t.find(element);
 }

Modified: lmi/trunk/contains_test.cpp
===================================================================
--- lmi/trunk/contains_test.cpp 2010-05-13 01:09:42 UTC (rev 4946)
+++ lmi/trunk/contains_test.cpp 2010-05-13 22:40:50 UTC (rev 4947)
@@ -28,13 +28,17 @@
 
 #include "contains.hpp"
 
+#include "miscellany.hpp" // lmi_array_size()
 #include "test_tools.hpp"
 
 #include <boost/static_assert.hpp>
 
+#include <deque>
+#include <list>
 #include <map>
 #include <set>
 #include <string>
+#include <utility>        // std::pair
 #include <vector>
 
 struct HasFind   {void find();};
@@ -54,29 +58,49 @@
 #endif // !defined LMI_NO_SFINAE
 }
 
+/// Test standard "containers" for which find() makes sense.
+///
+/// std::queue and std::stack are not traversable; std::bitset has
+/// any() and none() already.
+
 void test_contains()
 {
-    std::string const s("etaoin shrdlu");
-    std::string const t("lorem ipsum");
-    BOOST_TEST( contains(s, s));
-    BOOST_TEST(!contains(s, t));
-    BOOST_TEST( contains(s, "eta"));
-    BOOST_TEST(!contains(s, "zeta"));
+    std::string const w("etaoin shrdlu");
+    std::string const x("lorem ipsum");
+    std::string const y[] = {"O Sibili", "si ergo", "fortibus es", "in ero"};
+    std::pair<std::string,std::string> const z[] =
+        {std::make_pair<std::string,std::string>("O Nobili", "demis trux")
+        ,std::make_pair<std::string,std::string>("uatis inem", "causendux")
+        };
 
-#if 0 // This is where has_member_find<> will help.
-    std::set<std::string> u;
-    u.insert("one");
-    BOOST_TEST( contains(u, "one"));
-    BOOST_TEST(!contains(u, "two"));
-#endif // 0
+    // Strings.
 
-    std::map<std::string, int> m;
-    m["one"] = 1;
-    BOOST_TEST( contains(m, "one"));
-    BOOST_TEST(!contains(m, "two"));
+    BOOST_TEST( contains(w, w));
+    BOOST_TEST(!contains(w, x));
+    BOOST_TEST( contains(w, "eta"));
+    BOOST_TEST(!contains(w, "zeta"));
 
-    std::vector<double> v;
-    v.push_back(3.14);
+    // Associative containers.
+
+    std::map<std::string,std::string> const m(z, z + lmi_array_size(z));
+    BOOST_TEST( contains(m, "uatis inem"));
+    BOOST_TEST(!contains(m, "cows and ducks"));
+
+    std::set<std::string> const s(y, y + lmi_array_size(y));
+    BOOST_TEST( contains(s, "si ergo"));
+    BOOST_TEST(!contains(s, "fortibus"));
+
+    // Sequences.
+
+    std::deque<double> const d(1, 3.14);
+    BOOST_TEST( contains(d, 3.14));
+    BOOST_TEST(!contains(d, 0.00));
+
+    std::list<double> const t(1, 3.14);
+    BOOST_TEST( contains(t, 3.14));
+    BOOST_TEST(!contains(t, 0.00));
+
+    std::vector<double> const v(1, 3.14);
     BOOST_TEST( contains(v, 3.14));
     BOOST_TEST(!contains(v, 0.00));
 }