Changeset 1399

Timestamp:

Aug 7, 2008, 12:52:39 AM (15 years ago)

Author:

Peter

Message:

refs #369 added a function to create a boost::transform_iterator that was mentioned in ticket:369 - should probably add the corresponding for pair::second too.

Location:

trunk

Files:

• test/iterator_test.cc (modified) (3 diffs)
• yat/utility/stl_utility.h (modified) (2 diffs)

trunk/test/iterator_test.cc

@@ -32 +32 @@
 #include "yat/utility/Matrix.h"
 #include "yat/utility/MatrixWeighted.h"
+#include "yat/utility/stl_utility.h"
 #include "yat/utility/Vector.h"
 #include "yat/utility/WeightIterator.h"
 
+#include <boost/iterator/transform_iterator.hpp>
+
 #include <algorithm>
 #include <fstream>
-
+#include <string>
 #include <vector>
 
 using namespace theplu::yat;
+
+void old_main(test::Suite&);
+void test_boost_util(test::Suite&);
 
 int main(int argc, char* argv[])
@@ -47 +53 @@
   suite.err() << "testing iterator" << std::endl;
 
+  old_main(suite);
+  test_boost_util(suite);
+  return suite.return_value();
+}
+  
+
+void old_main(test::Suite& suite)
+{
   suite.err() << "testing utility::vector::iterator" << std::endl;
   utility::Vector vec(12);
@@ -142 +156 @@
     suite.add(false);
 
-  return suite.return_value();
 }
+
+void test_boost_util(test::Suite& suite)
+{
+  bool ok_cached=suite.ok();
+  utility::PairFirst<std::pair<std::string, int> > pf;
+  std::pair<std::string, int> p("July", 31);
+  std::string str=pf(p);
+  suite.add(str=="July");
+  pf(p)="juli";
+  suite.add(pf(p)=="juli");
+
+  typedef utility::PairFirst<std::pair<const std::string, int> > PF2;
+  PF2 pf2;
+  std::pair<const std::string, int> p2("July", 31);
+  suite.add(pf2(p2)=="July");
+
+  utility::PairFirst<const std::pair<std::string, int> > pf3;
+  std::pair<std::string, int> p3("July", 31);
+  suite.add(pf3(p3)=="July");
+
+  utility::PairFirst<std::pair<std::string, const int> > pf4;
+  std::pair<std::string, const int> p4("July", 31);
+  suite.add(pf4(p4)=="July");
+  pf4(p4)="juli";
+  suite.add(pf4(p4)=="juli");
+
+  utility::PairFirst<std::pair<const std::string, const int> > pf5;
+  std::pair<const std::string, const int> p5("July", 31);
+  suite.add(pf5(p5)=="July");
+
+  typedef std::map<std::string, int> Map;
+  Map m;
+  m["July"]=31;
+  m["September"]=30;
+  m["June"]=30;
+  m["April"]=30;
+
+  boost::transform_iterator<PF2, Map::iterator> first_iterator(m.begin(), pf2);
+  boost::transform_iterator<PF2, Map::iterator> first_iterator_end(m.end(), pf2);
+  std::vector<std::string> vec(m.size());
+  std::copy(first_iterator, first_iterator_end, vec.begin());
+  if (!suite.add(vec[0]=="April"))
+    suite.err() << "Error: vec[0] = " << vec[0] << " expected April\n";
+  if (!suite.add(vec[1]=="July"))
+    suite.err() << "Error: vec[1] = " << vec[1] << " expected July\n";
+  if (!suite.add(vec[2]=="June"))
+    suite.err() << "Error: vec[2] = " << vec[2] << " expected June\n";
+  if (!suite.add(vec[3]=="September"))
+    suite.err() << "Error: vec[3] = " << vec[3] << " expected September\n";
+
+  std::vector<std::string> vec2(m.size());
+  std::copy(utility::pair_first_iterator(m.begin()), 
+            utility::pair_first_iterator(m.end()),
+            vec2.begin());
+  suite.add(vec2==vec);
+  
+
+  if (ok_cached && !suite.ok())
+    suite.err() << "test_bool_util failed" << std::endl;
+}

trunk/yat/utility/stl_utility.h

@@ -35 +35 @@
 /// extensions to STL functionality.
 ///
+
+#include <boost/iterator/transform_iterator.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/type_traits/is_const.hpp>
+#include <boost/type_traits/add_const.hpp>
 
 #include <algorithm>
@@ -266 +271 @@
   };
 
+  /**
+     \brief Functor that return std::pair.first
+
+     \see pair_first_iterator
+
+     \since New in yat 0.5
+   */
+  template <class Pair>
+  struct PairFirst 
+  {
+    /**
+       The type returned is Pair::first_type& with the exception when
+       Pair is const and Pair::first_type is non-const, in which case
+       const Pair::first_type& is return type.
+     */
+    typedef typename boost::mpl::if_<
+                  typename boost::is_const<Pair>::type, 
+                  typename boost::add_const<typename Pair::first_type>::type&,
+                  typename Pair::first_type&>::type result_type;
+    
+    /**
+       The argument type is Pair&.
+     */
+    typedef Pair& argument_type;
+
+    /**
+       \return p.first
+     */
+    inline result_type operator()(argument_type p) const
+    { return p.first; }
+
+  };
+
+
+  /**
+     Creates a transform_iterator that transforms an iterator with
+     value type std::pair to an iterator with value type
+     std::pair::first_type. This can be used, for example, to
+     communicate between a std::map and std::vector
+
+     \code
+     std::map<std::string, int> map;
+     ...
+     std::vector<std::string> vec;
+     vec.resize(map.size());
+     std::copy(pair_first_iterator(map.begin()), pair_first_iterator(map.end()),
+               vec.begin());
+     \endcode
+
+     \since New in yat 0.5
+   */
+  template<class Iter>
+  boost::transform_iterator<
+    PairFirst<typename std::iterator_traits<Iter>::value_type>, 
+    Iter> pair_first_iterator(Iter i)
+  {
+    typedef PairFirst<typename std::iterator_traits<Iter>::value_type> PF; 
+    return boost::transform_iterator<PF, Iter>(i, PF());
+  }
+
+
+
+
   ///
   /// @brief Function converting a string to lower case