for_all.h

Go to the documentation of this file.

/*****************************************************************************
* Copyright (c) 2001 - 2008 Marcus Boerger.  All rights reserved.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
* ========================================================================= */

/* ------------------------------------------------------------------------ */
/* Name:      for_all.h
 *
 * Requires:  
 * - Mbo.h
 */
/* ------------------------------------------------------------------------ */

#pragma once

#ifndef _FOR_ALL_H_
#define _FOR_ALL_H_

#include <algorithm>
#include <functional>
#include <map>
#include "arg_info.h"

namespace mbo
{

/****************************************************************************/
template<typename _Tret
       , typename _Ty
       , typename _Targ1 = void
       , typename _Targ2 = void
       , typename _Targ3 = void
       , typename _Targ4 = void
       , typename _Targ5 = void
       , typename _Targ6 = void
       , typename _Targ7 = void
       , typename _Targ8 = void
       , typename _Targ9 = void
       >
struct func_type_info_t
    : public std::unary_function<_Ty, _Tret>
{
public:
    typedef typename arg_info<_Targ1>::argument_t  arg1_t;
    typedef typename arg_info<_Targ1>::variable_t  var1_t;
    typedef typename arg_info<_Targ2>::argument_t  arg2_t;
    typedef typename arg_info<_Targ2>::variable_t  var2_t;
    typedef typename arg_info<_Targ3>::argument_t  arg3_t;
    typedef typename arg_info<_Targ3>::variable_t  var3_t;
    typedef typename arg_info<_Targ4>::argument_t  arg4_t;
    typedef typename arg_info<_Targ4>::variable_t  var4_t;
    typedef typename arg_info<_Targ5>::argument_t  arg5_t;
    typedef typename arg_info<_Targ5>::variable_t  var5_t;
    typedef typename arg_info<_Targ6>::argument_t  arg6_t;
    typedef typename arg_info<_Targ6>::variable_t  var6_t;
    typedef typename arg_info<_Targ7>::argument_t  arg7_t;
    typedef typename arg_info<_Targ7>::variable_t  var7_t;
    typedef typename arg_info<_Targ8>::argument_t  arg8_t;
    typedef typename arg_info<_Targ8>::variable_t  var8_t;
    typedef typename arg_info<_Targ9>::argument_t  arg9_t;
    typedef typename arg_info<_Targ9>::variable_t  var9_t;
};

/****************************************************************************/
template<class _Ty, typename _Tret, typename _Targ>
struct obj_func_t
    : public func_type_info_t<_Tret, _Ty, _Targ>
{
public:
    typedef _Ty     obj_t;
    typedef typename result_type (_Ty::*func_t)(arg1_t);

    obj_func_t(obj_t& obj, func_t func)
        : m_obj(obj)
        , m_func(func)
    {
    }

    result_type operator() (arg1_t arg1)
    {
        return (m_obj.*m_func)(arg1);
    }

protected:

    obj_t&   m_obj;
    func_t   m_func;
};

template<class _Ty, typename _Tret, typename _Targ>
struct obj_func_t<const _Ty, _Tret, _Targ>
    : public func_type_info_t<_Tret, _Ty, _Targ>
{
public:
    typedef _Ty     obj_t;
    typedef result_type (_Ty::*func_t)(arg1_t);

    obj_func_t(obj_t& obj, func_t func)
        : m_obj(obj)
        , m_func(func)
    {
    }

    result_type operator() (arg1_t arg1) const
    {
        return (m_obj.*m_func)(arg1);
    }

protected:

    obj_t&   m_obj;
    func_t   m_func;
};

template<class _Ty, typename _Tret, typename _Targ, typename _Targ2>
struct obj_func_1_t
    : public func_type_info_t<_Tret, _Ty, _Targ, _Targ2>
{
public:
    typedef typename _Ty     obj_t;
    typedef result_type (_Ty::*func_t)(arg1_t, arg2_t);

    obj_func_1_t(obj_t& obj, func_t func, arg2_t _arg2)
        : m_obj(obj)
        , m_func(func)
        , m_arg2(_arg2)
    {
    }

    result_type operator() (arg1_t arg1)
    {
        return (m_obj.*m_func)(arg1, m_arg2);
    }

protected:

    obj_t&   m_obj;
    func_t   m_func;
    arg2_t   m_arg2;
};

template<class _Ty, typename _Tret, typename _Targ, typename _Targ2>
struct obj_func_1_t<const _Ty, _Tret, _Targ, _Targ2>
    : public func_type_info_t<_Tret, _Ty, _Targ, _Targ2>
{
public:
    typedef _Ty     obj_t;
    typedef result_type (_Ty::*func_t)(arg1_t, arg2_t);

    obj_func_1_t(obj_t& obj, func_t func, arg2_t arg2)
        : m_obj(obj)
        , m_func(func)
        , m_arg2(arg2)
    {
    }

    result_type operator() (arg1_t arg1) const
    {
        return (m_obj.*m_func)(arg1, m_arg2);
    }

protected:

    obj_t&   m_obj;
    func_t   m_func;
    arg2_t   m_arg2;
};

template<class _Ty, typename _Tret, typename _Targ, typename _Targ2, typename _Targ3>
struct obj_func_2_t
    : public func_type_info_t<_Tret, _Ty, _Targ, _Targ2, _Targ3>
{
public:
    typedef _Ty     obj_t;
    typedef result_type (_Ty::*func_t)(arg1_t, arg2_t, arg3_t);

    obj_func_2_t(obj_t& obj, func_t func, arg2_t arg2, arg3_t arg3)
        : m_obj(obj)
        , m_func(func)
        , m_arg2(arg2)
        , m_arg3(arg3)
    {
    }

    result_type operator() (arg1_t arg1)
    {
        return (m_obj.*m_func)(arg1, m_arg2, m_arg3);
    }

protected:

    obj_t&   m_obj;
    func_t   m_func;
    arg2_t   m_arg2;
    arg3_t   m_arg3;
};

template<class _Ty, typename _Tret, typename _Targ, typename _Targ2, typename _Targ3>
struct obj_func_2_t<const _Ty, _Tret, _Targ, _Targ2, _Targ3>
    : public func_type_info_t<_Tret, _Ty, _Targ, _Targ2, _Targ3>
{
public:
    typedef _Ty     obj_t;
    typedef result_type (_Ty::*func_t)(arg1_t, arg2_t, arg3_t);

    obj_func_2_t(obj_t& obj, func_t func, arg2_t arg2, arg3_t arg3)
        : m_obj(obj)
        , m_func(func)
        , m_arg2(arg2)
        , m_arg3(arg3)
    {
    }

    result_type operator() (arg1_t arg1) const
    {
        return (m_obj.*m_func)(arg1, m_arg2, m_arg3);
    }

protected:

    obj_t&   m_obj;
    func_t   m_func;
    arg2_t   m_arg2;
    arg3_t   m_arg3;
};

template<typename _Ty, typename _Tret, typename _Targ>
inline obj_func_t<_Ty, typename _Tret, typename _Targ> obj_func(_Ty& obj, _Tret (_Ty::* func)(_Targ))
{
    return obj_func_t<_Ty, _Tret, _Targ>(obj, func);
}

template<typename _Ty, typename _Tret, typename _Targ>
inline obj_func_t<const _Ty, typename _Tret, typename _Targ> obj_func(const _Ty& obj, _Tret (_Ty::* func)(_Targ) const)
{
    return obj_func_t<_Ty, _Tret, _Targ>(obj, func);
}

template<typename _Ty, typename _Tret, typename _Targ, typename _Targ2>
inline obj_func_1_t<_Ty, typename _Tret, typename _Targ, typename _Targ2> obj_func(_Ty& obj, _Tret (_Ty::* func)(_Targ, _Targ2), _Targ2 arg2)
{
    return obj_func_1_t<_Ty, _Tret, _Targ, _Targ2>(obj, func, arg2);
}

template<typename _Ty, typename _Tret, typename _Targ, typename _Targ2>
inline obj_func_1_t<const _Ty, typename _Tret, typename _Targ, typename _Targ2> obj_func(const _Ty& obj, _Tret (_Ty::* func)(_Targ, _Targ2) const, _Targ2 arg2)
{
    return obj_func_1_t<_Ty, _Tret, _Targ, _Targ2>(obj, func, arg2);
}

template<typename _Ty, typename _Tret, typename _Targ, typename _Targ2, typename _Targ3>
inline obj_func_2_t<_Ty, typename _Tret, typename _Targ, typename _Targ2, typename _Targ3> 
    obj_func(_Ty& obj, 
        _Tret (_Ty::*func)(_Targ, _Targ2, _Targ3),
        typename arg_info<_Targ2>::argument_t arg2, 
        typename arg_info<_Targ3>::argument_t arg3)
{
    return obj_func_2_t<_Ty, _Tret, _Targ, _Targ2, _Targ3>(obj, func, arg2, arg3);
}

template<typename _Ty, typename _Tret, typename _Targ, typename _Targ2, typename _Targ3>
inline obj_func_2_t<const _Ty, typename _Tret, typename _Targ, typename _Targ2, typename _Targ3> 
    obj_func(const _Ty& obj, 
        _Tret (_Ty::*func)(_Targ, _Targ2, _Targ3) const,
        typename arg_info<_Targ2>::argument_t arg2, 
        typename arg_info<_Targ3>::argument_t arg3)
{
    return obj_func_2_t<const _Ty, _Tret, _Targ, _Targ2, _Targ3>(obj, func, arg2, arg3);
}

/****************************************************************************/

template<typename _Tfunc, typename _Ty>
struct all_of_t
    : public std::unary_function<typename _Ty, bool>
{
public:
    typedef _Tfunc func_t;

    all_of_t(func_t func)
        : m_func(func)
        , m_res(true)
    {
    }

    result_type operator() (argument_type arg)
    {
        // Cannot use &= because compiler might generate code that 
        // optimizes out remaining calls after first fail.
        if (!(m_func(arg)))
        {
            m_res = false;
        }
        return m_res;
    }

    operator bool()
    {
        return m_res;
    }

protected:

    bool     m_res;
    func_t   m_func;
};

template<typename _Tfunc>
all_of_t<_Tfunc, typename _Tfunc::argument_type> all_of_func(_Tfunc func)
{
    return all_of_t<_Tfunc, typename _Tfunc::argument_type>(func);
}

template<typename _Ty, typename _Tfunc>
struct any_of_t
    : public std::unary_function<typename _Ty, bool>
{
public:
    typedef _Tfunc func_t;

    any_of_t(func_t func)
        : m_func(func)
        , m_res(false)
    {
    }

    result_type operator() (argument_type arg)
    {
        // Cannot use |= because compiler might generate code that 
        // optimizes out remaining calls after first sucess.
        if (m_func(arg))
        {
            m_res = true;
        }
        return m_res;
    }

    operator bool()
    {
        return m_res;
    }

protected:

    bool     m_res;
    func_t   m_func;
};

template<typename _Tfunc>
any_of_t<_Tfunc, typename _Tfunc::argument_type> any_of_func(_Tfunc func)
{
    return any_of_t<_Tfunc, typename _Tfunc::argument_type>(func);
}

/****************************************************************************/
template<typename _Tpair, typename _Tfunc>
struct pair_first_func_t
    : public std::unary_function<_Tpair, _Tfunc>
{
public:
    typedef _Tpair        pair_t;
    typedef _Tfunc        func_t;

    pair_first_func_t(func_t func)
        : m_func(func)
    {
    }

    result_type operator() (pair_t& arg)
    {
        return m_func(arg.first);
    }

protected:

    func_t   m_func;
};

template<typename _Tpair, typename _Tfunc>
inline pair_first_func_t<_Tpair, _Tfunc> pair_first_func(_Tfunc func)
{
    return pair_first_func_t<_Tpair, _Tfunc>(func);
}

/****************************************************************************/
template<typename _Tpair, typename _Tret, typename _Tfunc>
struct pair_second_func_t
    : public std::unary_function<_Tpair, _Tret>
{
public:
    typedef _Tpair        pair_t;
    typedef _Tfunc        func_t;

    pair_second_func_t(func_t func)
        : m_func(func)
    {
    }

    result_type operator() (pair_t& arg)
    {
        return m_func(arg.second);
    }

protected:

    func_t   m_func;
};

template<typename _Tpair, typename _Tret, typename _Tfunc>
inline pair_second_func_t<_Tpair, _Tret, _Tfunc> pair_second_func(_Tfunc func)
{
    return pair_second_func_t<_Tpair, _Tret, _Tfunc>(func);
}

/****************************************************************************/
template<typename _Tret, typename _Tkey, typename _Tval>
struct map_value_func_t
    : public std::unary_function<typename std::map<_Tkey, _Tval>::value_type, _Tret>
{
public:
    typedef result_type (_Tval::*func_t)();

    map_value_func_t(func_t func)
        : m_func(func)
    {
    }

    result_type operator() (argument_type& it)
    {
        return (it.second.*m_func)();
    }

protected:

    func_t  m_func;
};

template<typename _Tret, typename _Tkey, typename _Tval>
struct map_value_func_t<_Tret, _Tkey, _Tval*>
    : public std::unary_function<typename std::map<_Tkey, _Tval*>::value_type, _Tret>
{
public:
    typedef result_type (_Tval::*func_t)();

    map_value_func_t(func_t func)
        : m_func(func)
    {
    }

    result_type operator() (argument_type& it)
    {
        return (it.second->*m_func)();
    }

protected:

    func_t  m_func;
};

template<typename _Tret, typename _Tkey, typename _Tval>
struct const_map_value_func_t
    : public std::unary_function<typename std::map<_Tkey, _Tval>::value_type, _Tret>
{
public:
    typedef result_type (_Tval::*func_t)() const;

    const_map_value_func_t(func_t func)
        : m_func(func)
    {
    }

    result_type operator() (const argument_type& it) const
    {
        return (it.second.*m_func)();
    }

protected:

    func_t  m_func;
};

template<typename _Tret, typename _Tkey, typename _Tval>
struct const_map_value_func_t<_Tret, _Tkey, _Tval*>
    : public std::unary_function<typename std::map<_Tkey, _Tval*>::value_type, _Tret>
{
public:
    typedef result_type (_Tval::*func_t)() const;

    const_map_value_func_t(func_t func)
        : m_func(func)
    {
    }

    result_type operator() (const argument_type& it) const
    {
        return (it.second->*m_func)();
    }

protected:

    func_t  m_func;
};

template<typename _Tret, typename _Ty>
struct value_func_t
    : public func_type_info_t<_Tret, _Ty>
{
public:
    typedef result_type (_Ty::*func_t)();

    value_func_t(func_t func)
        : m_func(func)
    {
    }

    result_type operator() (argument_type& p)
    {
        return (p.*m_func)();
    }

protected:
    func_t  m_func;
};

template<typename _Tret, typename _Ty>
struct value_func_t<_Tret, _Ty*>
    : public func_type_info_t<_Tret, _Ty*>
{
public:
    typedef result_type (_Ty::*func_t)();

    value_func_t(func_t func)
        : m_func(func)
    {
    }

    result_type operator() (argument_type p)
    {
        return (p->*m_func)();
    }

protected:
    func_t  m_func;
};

template<typename _Tret, typename _Ty>
struct const_value_func_t
    : public func_type_info_t<_Tret, _Ty>
{
public:
    typedef result_type (_Ty::*func_t)();

    const_value_func_t(func_t func)
        : m_func(func)
    {
    }

    result_type operator() (const argument_type& p) const
    {
        return (p->*m_func)();
    }

protected:
    func_t  m_func;
};

template<typename _Tret, typename _Ty>
struct const_value_func_t<_Tret, _Ty*>
    : public func_type_info_t<_Tret, _Ty*>
{
public:
    typedef result_type (_Ty::*func_t)();

    const_value_func_t(func_t func)
        : m_func(func)
    {
    }

    result_type operator() (const argument_type p) const
    {
        return (p->*m_func)();
    }

protected:
    func_t  m_func;
};

template<typename _Tret, typename _Ty, typename _Targ1>
struct value_func_1_t
    : public func_type_info_t<_Tret, _Ty, _Targ1>
{
public:
    typedef result_type (_Ty::*func_t)(arg1_t);

    value_func_1_t(func_t func, arg1_t arg1)
        : m_func(func)
        , m_arg1(arg1)
    {
    }

    result_type operator() (argument_type& p)
    {
        return (p.*m_func)(m_arg1);
    }

protected:
    func_t  m_func;
    var1_t  m_arg1;
};

template<typename _Tret, typename _Ty, typename _Targ1>
struct value_func_1_t<_Tret, _Ty*, _Targ1>
    : public func_type_info_t<_Tret, _Ty*, _Targ1>
{
public:
    typedef result_type (_Ty::*func_t)(arg1_t);

    value_func_1_t(func_t func, arg1_t arg1)
        : m_func(func)
        , m_arg1(arg1)
    {
    }

    result_type operator() (argument_type p)
    {
        return (p->*m_func)(m_arg1);
    }

protected:
    func_t  m_func;
    var1_t  m_arg1;
};

template<typename _Tret, typename _Ty, typename _Targ1>
struct const_value_func_1_t
    : public func_type_info_t<_Tret, _Ty, _Targ1>
{
public:
    typedef result_type (_Ty::*func_t)(arg1_t) const;

    const_value_func_1_t(func_t func, arg1_t arg1)
        : m_func(func)
        , m_arg1(arg1)
    {
    }

    result_type operator() (const argument_type& p) const
    {
        return (p->*m_func)(m_arg1);
    }

protected:
    func_t  m_func;
    var1_t  m_arg1;
};

template<typename _Tret, typename _Ty, typename _Targ1>
struct const_value_func_1_t<_Tret, _Ty*, _Targ1>
    : public func_type_info_t<_Tret, _Ty*, _Targ1>
{
public:
    typedef result_type (_Ty::*func_t)(arg1_t) const;

    const_value_func_1_t(func_t func, arg1_t arg1)
        : m_func(func)
        , m_arg1(arg1)
    {
    }

    result_type operator() (const argument_type p) const
    {
        return (p->*m_func)(m_arg1);
    }

protected:
    func_t  m_func;
    var1_t  m_arg1;
};

template<typename _Tret, typename _Ty, typename _Targ1, typename _Targ2>
struct value_func_2_t
    : public func_type_info_t<_Tret, _Ty, _Targ1, _Targ2>
{
public:
    typedef result_type (_Ty::*func_t)(arg1_t, arg2_t);

    value_func_2_t(func_t func, arg1_t arg1, arg2_t arg2)
        : m_func(func)
        , m_arg1(arg1)
        , m_arg2(arg2)
    {
    }

    result_type operator() (argument_type& p)
    {
        return (p.*m_func)(m_arg1, m_arg2);
    }

protected:
    func_t  m_func;
    var1_t  m_arg1;
    var2_t  m_arg2;
};

template<typename _Tret, typename _Ty, typename _Targ1, typename _Targ2>
struct value_func_2_t<_Tret, _Ty*, _Targ1, _Targ2>
    : public func_type_info_t<_Tret, _Ty*, _Targ1, _Targ2>
{
public:
    typedef result_type (_Ty::*func_t)(arg1_t, arg2_t);

    value_func_2_t(func_t func, arg1_t arg1, arg2_t arg2)
        : m_func(func)
        , m_arg1(arg1)
        , m_arg2(arg2)
    {
    }

    result_type operator() (argument_type p)
    {
        return (p->*m_func)(m_arg1, m_arg2);
    }

protected:
    func_t  m_func;
    var1_t  m_arg1;
    var2_t  m_arg2;
};

template<typename _Tret, typename _Ty, typename _Targ1, typename _Targ2>
struct const_value_func_2_t
    : public func_type_info_t<_Tret, _Ty, _Targ1, _Targ2>
{
public:
    typedef result_type (_Ty::*func_t)(arg1_t, arg2_t) const;

    const_value_func_2_t(func_t func, arg1_t arg1, arg2_t arg2)
        : m_func(func)
        , m_arg1(arg1)
        , m_arg2(arg2)
    {
    }

    result_type operator() (const argument_type& p) const
    {
        return (p.*m_func)(m_arg1, m_arg2);
    }

protected:
    func_t  m_func;
    var1_t  m_arg1;
    var2_t  m_arg2;
};

template<typename _Tret, typename _Ty, typename _Targ1, typename _Targ2>
struct const_value_func_2_t<_Tret, _Ty*, _Targ1, _Targ2>
    : public func_type_info_t<_Tret, _Ty*, _Targ1, _Targ2>
{
public:
    typedef result_type (_Ty::*func_t)(arg1_t, arg2_t) const;

    const_value_func_2_t(func_t func, arg1_t arg1, arg2_t arg2)
        : m_func(func)
        , m_arg1(arg1)
        , m_arg2(arg2)
    {
    }

    result_type operator() (const argument_type p) const
    {
        return (p->*m_func)(m_arg1, m_arg2);
    }

protected:
    func_t  m_func;
    var1_t  m_arg1;
    var2_t  m_arg2;
};

template<typename _Tret, typename _Ty, typename _Targ1, typename _Targ2, typename _Targ3>
struct value_func_3_t
    : public func_type_info_t<_Tret, _Ty, _Targ1, _Targ2, _Targ3>
{
public:
    typedef result_type (_Ty::*func_t)(arg1_t, arg2_t, arg3_t);

    value_func_3_t(func_t func, arg1_t arg1, arg2_t arg2, arg3_t arg3)
        : m_func(func)
        , m_arg1(arg1)
        , m_arg2(arg2)
        , m_arg3(arg3)
    {
    }

    result_type operator() (argument_type& p)
    {
        return (p.*m_func)(m_arg1, m_arg2, m_arg3);
    }

protected:
    func_t  m_func;
    var1_t  m_arg1;
    var2_t  m_arg2;
    var3_t  m_arg3;
};

template<typename _Tret, typename _Ty, typename _Targ1, typename _Targ2, typename _Targ3>
struct value_func_3_t<_Tret, _Ty*, _Targ1, _Targ2, _Targ3>
    : public func_type_info_t<_Tret, _Ty*, _Targ1, _Targ2, _Targ3>
{
public:
    typedef result_type (_Ty::*func_t)(arg1_t, arg2_t, arg3_t);

    value_func_3_t(func_t func, arg1_t arg1, arg2_t arg2, arg3_t arg3)
        : m_func(func)
        , m_arg1(arg1)
        , m_arg2(arg2)
        , m_arg3(arg3)
    {
    }

    result_type operator() (argument_type p)
    {
        return (p->*m_func)(m_arg1, m_arg2, m_arg3);
    }

protected:
    func_t  m_func;
    var1_t  m_arg1;
    var2_t  m_arg2;
    var3_t  m_arg3;
};

template<typename _Tret, typename _Ty, typename _Targ1, typename _Targ2, typename _Targ3>
struct const_value_func_3_t
    : public func_type_info_t<_Tret, _Ty, _Targ1, _Targ2, _Targ3>
{
public:
    typedef result_type (_Ty::*func_t)(arg1_t, arg2_t, arg3_t) const;

    const_value_func_3_t(func_t func, arg1_t arg1, arg2_t arg2, arg3_t arg3)
        : m_func(func)
        , m_arg1(arg1)
        , m_arg2(arg2)
        , m_arg3(arg3)
    {
    }

    result_type operator() (const argument_type& p) const
    {
        return (p.*m_func)(m_arg1, m_arg2, m_arg3);
    }

protected:
    func_t  m_func;
    var1_t  m_arg1;
    var2_t  m_arg2;
    var3_t  m_arg3;
};

template<typename _Tret, typename _Ty, typename _Targ1, typename _Targ2, typename _Targ3>
struct const_value_func_3_t<_Tret, _Ty*, _Targ1, _Targ2, _Targ3>
    : public func_type_info_t<_Tret, _Ty*, _Targ1, _Targ2, _Targ3>
{
public:
    typedef result_type (_Ty::*func_t)(arg1_t, arg2_t, arg3_t) const;

    const_value_func_3_t(func_t func, arg1_t arg1, arg2_t arg2, arg3_t arg3)
        : m_func(func)
        , m_arg1(arg1)
        , m_arg2(arg2)
        , m_arg3(arg3)
    {
    }

    result_type operator() (const argument_type p) const
    {
        return (p->*m_func)(m_arg1, m_arg2, m_arg3);
    }

protected:
    func_t  m_func;
    var1_t  m_arg1;
    var2_t  m_arg2;
    var3_t  m_arg3;
};

template<typename _Tret, typename _Ty, typename _Targ1, typename _Targ2, typename _Targ3, typename _Targ4>
struct value_func_4_t
    : public func_type_info_t<_Tret, _Ty, _Targ1, _Targ2, _Targ3, _Targ4>
{
public:
    typedef result_type (_Ty::*func_t)(arg1_t, arg2_t, arg3_t, arg4_t);

    value_func_4_t(func_t func, arg1_t arg1, arg2_t arg2, arg3_t arg3, arg4_t arg4)
        : m_func(func)
        , m_arg1(arg1)
        , m_arg2(arg2)
        , m_arg3(arg3)
        , m_arg4(arg4)
    {
    }

    result_type operator() (argument_type& p)
    {
        return (p.*m_func)(m_arg1, m_arg2, m_arg3, m_arg4);
    }

protected:
    func_t  m_func;
    var1_t  m_arg1;
    var2_t  m_arg2;
    var3_t  m_arg3;
    var4_t  m_arg4;
};

template<typename _Tret, typename _Ty, typename _Targ1, typename _Targ2, typename _Targ3, typename _Targ4>
struct value_func_4_t<_Tret, _Ty*, _Targ1, _Targ2, _Targ3, _Targ4>
    : public func_type_info_t<_Tret, _Ty*, _Targ1, _Targ2, _Targ3, _Targ4>
{
public:
    typedef result_type (_Ty::*func_t)(arg1_t, arg2_t, arg3_t, arg4_t);

    value_func_4_t(func_t func, arg1_t arg1, arg2_t arg2, arg3_t arg3, arg4_t arg4)
        : m_func(func)
        , m_arg1(arg1)
        , m_arg2(arg2)
        , m_arg3(arg3)
        , m_arg4(arg4)
    {
    }

    result_type operator() (argument_type p)
    {
        return (p->*m_func)(m_arg1, m_arg2, m_arg3, m_arg4);
    }

protected:
    func_t  m_func;
    var1_t  m_arg1;
    var2_t  m_arg2;
    var3_t  m_arg3;
    var4_t  m_arg4;
};

template<typename _Tret, typename _Ty, typename _Targ1, typename _Targ2, typename _Targ3, typename _Targ4>
struct const_value_func_4_t
    : public func_type_info_t<_Tret, _Ty, _Targ1, _Targ2, _Targ3, _Targ4>
{
public:
    typedef result_type (_Ty::*func_t)(arg1_t, arg2_t, arg3_t, arg4_t) const;

    const_value_func_4_t(func_t func, arg1_t arg1, arg2_t arg2, arg3_t arg3, arg4_t arg4)
        : m_func(func)
        , m_arg1(arg1)
        , m_arg2(arg2)
        , m_arg3(arg3)
        , m_arg4(arg4)
    {
    }

    result_type operator() (const argument_type& p) const
    {
        return (p.*m_func)(m_arg1, m_arg2, m_arg3, m_arg4);
    }

protected:
    func_t  m_func;
    var1_t  m_arg1;
    var2_t  m_arg2;
    var3_t  m_arg3;
    var4_t  m_arg4;
};

template<typename _Tret, typename _Ty, typename _Targ1, typename _Targ2, typename _Targ3, typename _Targ4>
struct const_value_func_4_t<_Tret, _Ty*, _Targ1, _Targ2, _Targ3, _Targ4>
    : public func_type_info_t<_Tret, _Ty*, _Targ1, _Targ2, _Targ3, _Targ4>
{
public:
    typedef result_type (_Ty::*func_t)(arg1_t, arg2_t, arg3_t, arg4_t) const;

    const_value_func_4_t(func_t func, arg1_t arg1, arg2_t arg2, arg3_t arg3, arg4_t arg4)
        : m_func(func)
        , m_arg1(arg1)
        , m_arg2(arg2)
        , m_arg3(arg3)
        , m_arg4(arg4)
    {
    }

    result_type operator() (const argument_type p) const
    {
        return (p->*m_func)(m_arg1, m_arg2, m_arg3, m_arg4);
    }

protected:
    func_t  m_func;
    var1_t  m_arg1;
    var2_t  m_arg2;
    var3_t  m_arg3;
    var4_t  m_arg4;
};

template<typename _Tret, typename _Ty, typename _Targ1, typename _Targ2, typename _Targ3, typename _Targ4, typename _Targ5>
struct value_func_5_t
    : public func_type_info_t<_Tret, _Ty, _Targ1, _Targ2, _Targ3, _Targ4, _Targ5>
{
public:
    typedef result_type (_Ty::*func_t)(arg1_t, arg2_t, arg3_t, arg4_t, arg5_t);

    value_func_5_t(func_t func, arg1_t arg1, arg2_t arg2, arg3_t arg3, arg4_t arg4, arg5_t)
        : m_func(func)
        , m_arg1(arg1)
        , m_arg2(arg2)
        , m_arg3(arg3)
        , m_arg4(arg4)
        , m_arg5(arg5)
    {
    }

    result_type operator() (argument_type& p)
    {
        return (p.*m_func)(m_arg1, m_arg2, m_arg3, m_arg4, m_arg5);
    }

protected:
    func_t  m_func;
    var1_t  m_arg1;
    var2_t  m_arg2;
    var3_t  m_arg3;
    var4_t  m_arg4;
    var5_t  m_arg5;
};

template<typename _Tret, typename _Ty, typename _Targ1, typename _Targ2, typename _Targ3, typename _Targ4, typename _Targ5>
struct value_func_5_t<_Tret, _Ty*, _Targ1, _Targ2, _Targ3, _Targ4, _Targ5>
    : public func_type_info_t<_Tret, _Ty*, _Targ1, _Targ2, _Targ3, _Targ4, _Targ5>
{
public:
    typedef result_type (_Ty::*func_t)(arg1_t, arg2_t, arg3_t, arg4_t, arg5_t);

    value_func_5_t(func_t func, arg1_t arg1, arg2_t arg2, arg3_t arg3, arg4_t arg4, arg5_t arg5)
        : m_func(func)
        , m_arg1(arg1)
        , m_arg2(arg2)
        , m_arg3(arg3)
        , m_arg4(arg4)
        , m_arg5(arg5)
    {
    }

    result_type operator() (argument_type p)
    {
        return (p->*m_func)(m_arg1, m_arg2, m_arg3, m_arg4, m_arg5);
    }

protected:
    func_t  m_func;
    var1_t  m_arg1;
    var2_t  m_arg2;
    var3_t  m_arg3;
    var4_t  m_arg4;
    var5_t  m_arg5;
};

template<typename _Tret, typename _Ty, typename _Targ1, typename _Targ2, typename _Targ3, typename _Targ4, typename _Targ5>
struct const_value_func_5_t
    : public func_type_info_t<_Tret, _Ty, _Targ1, _Targ2, _Targ3, _Targ4, _Targ5>
{
public:
    typedef result_type (_Ty::*func_t)(arg1_t, arg2_t, arg3_t, arg4_t, arg5_t) const;

    const_value_func_5_t(func_t func, arg1_t arg1, arg2_t arg2, arg3_t arg3, arg4_t arg4, arg5_t arg5)
        : m_func(func)
        , m_arg1(arg1)
        , m_arg2(arg2)
        , m_arg3(arg3)
        , m_arg4(arg4)
        , m_arg5(arg5)
    {
    }

    result_type operator() (const argument_type& p) const
    {
        return (p.*m_func)(m_arg1, m_arg2, m_arg3, m_arg4, m_arg5);
    }

protected:
    func_t  m_func;
    var1_t  m_arg1;
    var2_t  m_arg2;
    var3_t  m_arg3;
    var4_t  m_arg4;
    var5_t  m_arg5;
};

template<typename _Tret, typename _Ty, typename _Targ1, typename _Targ2, typename _Targ3, typename _Targ4, typename _Targ5>
struct const_value_func_5_t<_Tret, _Ty*, _Targ1, _Targ2, _Targ3, _Targ4, _Targ5>
    : public func_type_info_t<_Tret, _Ty*, _Targ1, _Targ2, _Targ3, _Targ4, _Targ5>
{
public:
    typedef result_type (_Ty::*func_t)(arg1_t, arg2_t, arg3_t, arg4_t, arg5_t) const;

    const_value_func_5_t(func_t func, arg1_t arg1, arg2_t arg2, arg3_t arg3, arg4_t arg4, arg5_t arg5)
        : m_func(func)
        , m_arg1(arg1)
        , m_arg2(arg2)
        , m_arg3(arg3)
        , m_arg4(arg4)
        , m_arg5(arg5)
    {
    }

    result_type operator() (const argument_type p) const
    {
        return (p->*m_func)(m_arg1, m_arg2, m_arg3, m_arg4, m_arg5);
    }

protected:
    func_t  m_func;
    var1_t  m_arg1;
    var2_t  m_arg2;
    var3_t  m_arg3;
    var4_t  m_arg4;
    var5_t  m_arg5;
};

/****************************************************************************/

template<typename _Tret, typename _Tkey, typename _Tval> 
inline map_value_func_t<_Tret, _Tkey, _Tval> map_value_func(typename map_value_func_t<_Tret, _Tkey, _Tval>::func_t func)
{
    return map_value_func_t<_Tret, _Tkey, _Tval>(func);
}

template<typename _Tret, typename _Tkey, typename _Tval> 
inline const_map_value_func_t<_Tret, _Tkey, _Tval> map_value_func(typename const_map_value_func_t<_Tret, _Tkey, _Tval>::func_t func)
{
    return const_map_value_func_t<_Tret, _Tkey, _Tval>(func);
}

template<typename _Tret, typename _Ty>
inline value_func_t<_Tret, _Ty> value_func(_Tret (_Ty::*func)())
{
    return value_func_t<_Ty, _Tret>(func);
}

template<typename _Tret, typename _Ty>
inline const_value_func_t<_Tret, _Ty> value_func(_Tret (_Ty::*func)() const)
{
    return const_value_func_t<_Ty, _Tret>(func);
}

template<typename _Tret, typename _Ty, typename _Targ1>
inline value_func_1_t<_Tret, _Ty, _Targ1> value_func(_Tret (_Ty::*func)(_Targ1))
{
    return value_func_1_t<_Ty, _Tret, _Targ1>(func);
}

template<typename _Tret, typename _Ty, typename _Targ1>
inline const_value_func_1_t<_Tret, _Ty, _Targ1> value_func(_Tret (_Ty::*func)(_Targ1) const)
{
    return const_value_func_1_t<_Ty, _Tret, _Targ1>(func);
}

template<typename _Tret, typename _Ty, typename _Targ1, typename _Targ2>
inline value_func_2_t<_Tret, _Ty, _Targ1, _Targ2> value_func(_Tret (_Ty::*func)(_Targ1, _Targ2))
{
    return value_func_2_t<_Ty, _Tret, _Targ1, _Targ2>(func);
}

template<typename _Tret, typename _Ty, typename _Targ1, typename _Targ2>
inline const_value_func_2_t<_Tret, _Ty, _Targ1, _Targ2> value_func(_Tret (_Ty::*func)(_Targ1, _Targ2) const)
{
    return const_value_func_2_t<_Ty, _Tret, _Targ1, _Targ2>(func);
}

template<typename _Tret, typename _Ty, typename _Targ1, typename _Targ2, typename _Targ3>
inline value_func_3_t<_Tret, _Ty, _Targ1, _Targ2, _Targ3> value_func(_Tret (_Ty::*func)(_Targ1, _Targ2, _Targ3))
{
    return value_func_3_t<_Ty, _Tret, _Targ1, _Targ2, _Targ3>(func);
}

template<typename _Tret, typename _Ty, typename _Targ1, typename _Targ2, typename _Targ3>
inline const_value_func_3_t<_Tret, _Ty, _Targ1, _Targ2, _Targ3> value_func(_Tret (_Ty::*func)(_Targ1, _Targ2, _Targ3) const)
{
    return const_value_func_3_t<_Ty, _Tret, _Targ1, _Targ2, _Targ3>(func);
}

/****************************************************************************/
template<typename _Tcontainer, typename _Tfunc>
_Tfunc for_all(_Tcontainer& cont, _Tfunc func)
{
    return std::for_each(cont.begin(), cont.end(), func);
}

template<typename _Tcontainer, typename _Tfunc>
bool all_of(_Tcontainer& cont, _Tfunc func)
{
    return for_all(cont, all_of_t<_Tfunc, _Tcontainer::value_type>(func));
}

template<typename _Tcontainer, typename _Tfunc>
bool any_of(_Tcontainer& cont, _Tfunc func)
{
    return for_all(cont, any_of_t<_Tcontainer::value_type, _Tfunc>(func));
}

/* - map - */

template<typename _Tret, typename _Tmap, typename _Tval>
void for_all_map_val(_Tmap& cont, _Tret (_Tval::*func)())
{
    for_all(cont, map_value_func_t<_Tret, _Tmap::key_type, _Tmap::mapped_type>(func));
}

template<typename _Tret, typename _Tmap, typename _Tval>
void for_all_map_val(const _Tmap& cont, _Tret (_Tval::*func)() const)
{
    for_all(cont, const_map_value_func_t<_Tret, _Tmap::key_type, _Tmap::mapped_type>(func));
}

template<typename _Tmap, typename _Tfunc>
_Tfunc for_all_map_first(_Tmap& cont, _Tfunc func)
{
    for_all(cont, pair_first_func_t<_Tmap::value_type, void, _Tfunc>(func));
    return func;
}

template<typename _Tmap, typename _Tfunc>
_Tfunc for_all_map_second(_Tmap& cont, _Tfunc func)
{
    for_all(cont, pair_second_func_t<_Tmap::value_type, void, _Tfunc>(func));
    return func;
}

template<typename _Tmap, typename _Tfunc>
bool all_of_map_second(_Tmap& cont, _Tfunc func)
{
    return for_all(cont, all_of_func(pair_second_func<_Tmap::value_type, bool>(func)));
}

template<typename _Tmap, typename _Tfunc>
bool any_of_map_second(_Tmap& cont, _Tfunc func)
{
    return for_all(cont, any_of_func(pair_second_func<_Tmap::value_type, bool>(func)));
}

/* - 0 - */

template<typename _Tret, typename _Tcontainer, typename _Tval>
void for_all_val(_Tcontainer& cont, _Tret (_Tval::*func)())
{
    for_all(cont, value_func_t<_Tret, _Tcontainer::value_type>(func));
}

template<typename _Tret, typename _Tcontainer, typename _Tval>
void for_all_val(_Tcontainer& cont, _Tret (_Tval::*func)() const)
{
    for_all(cont, const_value_func_t<_Tret, _Tcontainer::value_type>(func));
}

/* - 1 - */

template<typename _Targ1, typename _Tret, typename _Tcontainer, typename _Tval>
void for_all_val(
        _Tcontainer& cont, 
        _Tret (_Tval::*func)(_Targ1), 
        typename arg_info<_Targ1>::argument_t arg1
    )
{
    for_all(cont, value_func_1_t<_Tret, _Tcontainer::value_type, _Targ1>(func, arg1));
}

template<typename _Targ1, typename _Tret, typename _Tcontainer, typename _Tval>
void for_all_val(
        _Tcontainer& cont, 
        _Tret (_Tval::*func)(_Targ1) const, 
        typename arg_info<_Targ1>::argument_t arg1
    )
{
    for_all(cont, const_value_func_1_t<_Tret, _Tcontainer::value_type, _Targ1>(func, arg1));
}

/* - 2 - */

template<typename _Targ1, typename _Targ2, typename _Tret, typename _Tcontainer, typename _Tval>
void for_all_val(
        _Tcontainer& cont, 
        _Tret (_Tval::*func)(_Targ1, _Targ2), 
        typename arg_info<_Targ1>::argument_t arg1, 
        typename arg_info<_Targ2>::argument_t arg2
    )
{
    for_all(cont, value_func_2_t<_Tret, _Tcontainer::value_type, _Targ1, _Targ2>(func, arg1, arg2));
}

template<typename _Targ1, typename _Targ2, typename _Tret, typename _Tcontainer, typename _Tval>
void for_all_val(
        _Tcontainer& cont, 
        _Tret (_Tval::*func)(_Targ1, _Targ2) const, 
        typename arg_info<_Targ1>::argument_t arg1, 
        typename arg_info<_Targ2>::argument_t arg2
    )
{
    for_all(cont, const_value_func_2_t<_Tret, _Tcontainer::value_type, _Targ1, _Targ2>(func, arg1, arg2));
}

/* - 3 - */

template<typename _Targ1, typename _Targ2, typename _Targ3, typename _Tret, typename _Tcontainer, typename _Tval>
void for_all_val(
        _Tcontainer& cont, 
        _Tret (_Tval::*func)(_Targ1, _Targ2, _Targ3), 
        typename arg_info<_Targ1>::argument_t arg1, 
        typename arg_info<_Targ2>::argument_t arg2,
        typename arg_info<_Targ3>::argument_t arg3
    )
{
    for_all(cont, value_func_3_t<_Tret, _Tcontainer::value_type, _Targ1, _Targ2, _Targ3>(func, arg1, arg2, arg3));
}

template<typename _Targ1, typename _Targ2, typename _Targ3, typename _Tret, typename _Tcontainer, typename _Tval>
void for_all_val(
        _Tcontainer& cont, 
        _Tret (_Tval::*func)(_Targ1, _Targ2, _Targ3) const, 
        typename arg_info<_Targ1>::argument_t arg1, 
        typename arg_info<_Targ2>::argument_t arg2,
        typename arg_info<_Targ3>::argument_t arg3
    )
{
    for_all(cont, const_value_func_3_t<_Tret, _Tcontainer::value_type, _Targ1, _Targ2, _Targ3>(func, arg1, arg2, arg3));
}

/* - 4 - */

template<typename _Targ1, typename _Targ2, typename _Targ3, typename _Targ4, typename _Tret, typename _Tcontainer, typename _Tval>
void for_all_val(
        _Tcontainer& cont, 
        _Tret (_Tval::*func)(_Targ1, _Targ2, _Targ3, _Targ4), 
        typename arg_info<_Targ1>::argument_t arg1, 
        typename arg_info<_Targ2>::argument_t arg2,
        typename arg_info<_Targ3>::argument_t arg3,
        typename arg_info<_Targ4>::argument_t arg4
    )
{
    for_all(cont, value_func_4_t<_Tret, _Tcontainer::value_type, _Targ1, _Targ2, _Targ3, _Targ4>(func, arg1, arg2, arg3, arg4));
}

template<typename _Targ1, typename _Targ2, typename _Targ3, typename _Targ4, typename _Tret, typename _Tcontainer, typename _Tval>
void for_all_val(
        _Tcontainer& cont, 
        _Tret (_Tval::*func)(_Targ1, _Targ2, _Targ3, _Targ4) const, 
        typename arg_info<_Targ1>::argument_t arg1, 
        typename arg_info<_Targ2>::argument_t arg2,
        typename arg_info<_Targ3>::argument_t arg3,
        typename arg_info<_Targ4>::argument_t arg4
    )
{
    for_all(cont, const_value_func_4_t<_Tret, _Tcontainer::value_type, _Targ1, _Targ2, _Targ3, _Targ4>(func, arg1, arg2, arg3, arg4));
}

/* - 5 - */

template<typename _Targ1, typename _Targ2, typename _Targ3, typename _Targ4, typename _Targ5, typename _Tret, typename _Tcontainer, typename _Tval>
void for_all_val(
        _Tcontainer& cont, 
        _Tret (_Tval::*func)(_Targ1, _Targ2, _Targ3, _Targ4, _Targ5), 
        typename arg_info<_Targ1>::argument_t arg1, 
        typename arg_info<_Targ2>::argument_t arg2,
        typename arg_info<_Targ3>::argument_t arg3,
        typename arg_info<_Targ4>::argument_t arg4,
        typename arg_info<_Targ5>::argument_t arg5
    )
{
    for_all(cont, value_func_5_t<_Tret, _Tcontainer::value_type, _Targ1, _Targ2, _Targ3, _Targ4, _Targ5>(func, arg1, arg2, arg3, arg4, arg5));
}

template<typename _Targ1, typename _Targ2, typename _Targ3, typename _Targ4, typename _Targ5, typename _Tret, typename _Tcontainer, typename _Tval>
void for_all_val(
        _Tcontainer& cont, 
        _Tret (_Tval::*func)(_Targ1, _Targ2, _Targ3, _Targ4, _Targ5) const, 
        typename arg_info<_Targ1>::argument_t arg1, 
        typename arg_info<_Targ2>::argument_t arg2,
        typename arg_info<_Targ3>::argument_t arg3,
        typename arg_info<_Targ4>::argument_t arg4,
        typename arg_info<_Targ5>::argument_t arg5
    )
{
    for_all(cont, const_value_func_5_t<_Tret, _Tcontainer::value_type, _Targ1, _Targ2, _Targ3, _Targ4, _Targ5>(func, arg1, arg2, arg3, arg4, arg5));
}

}; // namespace

#endif // _FOR_ALL_H_

---