Create a grfx::Loader class and so move large chunks of code out of

[lyx.git] / src / support / lyxfunctional.h

diff --git a/src/support/lyxfunctional.h b/src/support/lyxfunctional.h
index 50d7ed22432d9fb0a6f806f3e9d513786c168847..0d129c6c63aea22be32fa614a9b9176f37724cb5 100644 (file)
--- a/src/support/lyxfunctional.h
+++ b/src/support/lyxfunctional.h
@@ -3,14 +3,21 @@
 #ifndef LYX_FUNCTIONAL_H
 #define LYX_FUNCTIONAL_H
 
+/** \file lyxfunctional.h
+    \brief Convenient function objects for use with LyX
+
+    This is currently a small collection of small function objects for use
+    together with std::algorithms.
+**/
+
 #include <iterator>
 
-//namespace lyx {
+namespace lyx {
 
 template<class R, class C, class A>
 class class_fun_t {
 public:
-       class_fun_t(C & ct, R(C::*p)(A)) 
+       class_fun_t(C & ct, R(C::*p)(A))
                : c(ct), cmf(p) {}
        R operator()(A & a) const {
                return (c.*cmf)(a);
@@ -34,7 +41,16 @@ private:
        void(C::*cmf)(A);
 };
 
-       
+
+/// Use to call a class method with a container element.
+/** Most easily used as a functor to std::algoritms.
+    Small example:
+    \verbatim
+    A a; // class that have a int print(string const &) method
+    vector<string> vs;
+    for_each(vs.begin(), vs.end(), class_fun(int, vs, &A::print);
+    \endverbatim
+**/
 template <class R, class C, class A> class_fun_t<R, C, A>
 class_fun(C & c, R(C::*f)(A))
 {
@@ -43,7 +59,7 @@ class_fun(C & c, R(C::*f)(A))
 
 
 template <class C, class A> void_class_fun_t<C, A>
-class_fun(C & c, void(C::*f)(A))
+void_class_fun(C & c, void(C::*f)(A))
 {
        return void_class_fun_t<C, A>(c, f);
 }
@@ -61,7 +77,7 @@ public:
        typedef void difference_type;
        typedef void pointer;
        typedef void reference;
-       
+
        back_insert_fun_iterator(Cont & x, MemRet(Type::*p)())
                : container(&x), pmf(p) {}
 
@@ -101,12 +117,12 @@ public:
        typedef void difference_type;
        typedef void pointer;
        typedef void reference;
-       
+
        const_back_insert_fun_iterator(Cont & x, MemRet(Type::*p)() const)
                : container(&x), pmf(p) {}
-       
+
        ~const_back_insert_fun_iterator() {}
-      
+
        const_back_insert_fun_iterator &
        operator=(Type const * val) {
                container->push_back((val->*pmf)());
@@ -196,44 +212,47 @@ compare_memfun(R(C::*p)() const, A const & a)
        return const_compare_memfun_t<R, C, A>(p, a);
 }
 
-       
+
 // Functors used in the template.
 
 ///
-template<typename T1, typename T2>
+template<typename T>
 class equal_1st_in_pair {
 public:
        ///
-       equal_1st_in_pair(T1 const & value) : value_(value) {}
+       typedef typename T::first_type first_type;
+       ///
+       typedef T pair_type;
        ///
-       typedef std::pair<T1, T2> pair_type;
+       equal_1st_in_pair(first_type const & value) : value_(value) {}
        ///
        bool operator() (pair_type const & p) const {
                return p.first == value_;
        }
 private:
        ///
-       T1 const & value_;
+       first_type const & value_;
 };
 
 
 ///
-template<typename T1, typename T2>
+template<typename T>
 class equal_2nd_in_pair {
 public:
        ///
-       equal_2nd_in_pair(T2 const & value) : value_(value) {}
+       typedef typename T::second_type second_type;
        ///
-       typedef std::pair<T1, T2> pair_type;
+       typedef T pair_type;
+       ///
+       equal_2nd_in_pair(second_type const & value) : value_(value) {}
        ///
        bool operator() (pair_type const & p) const {
                return p.second == value_;
        }
 private:
        ///
-       T2 const & value_;
+       second_type const & value_;
 };
 
-
-// }  // end of namespace lyx
+}  // end of namespace lyx
 #endif