#if !defined(helper_binders_h)
#define helper_binders_h

#include <functional>

//  function object adapter - binary_select_member, unary_select_member, binary_select_member_func, unary_select_member_func
//
//	converts a function object to operate on a member of the passed object
//
//	e.g.		struct T { int x, y;	};
//				std::vector<T>	cont;
//				 ...
//				std::sort(cont.begin(), cont.end(), binary_select_member(std::less<int>(), &T::x));
//
//			Sorts the container by the member x, or (although sort_member does this for you, see below)
//
//				std::find_if(cont.begin(), cont.end(), unary_select_member(std::bind2nd(std::equal_to<int>(), 1), &T::x));
//
//			Finds an element whose member x is 1  (although find_if_member does this for you, see below)
//
//	Similarly, both adapters are available with _func versions - these allow you to use the value returned from a function
//
//	e.g.		class T { int x; public: int Get_x() };
//				std::vector<T>	cont;
//				 ...
//				std::sort(cont.begin(), cont.end(), binary_select_member_func(std::less<int>(), &T::Get_x));
//
//			Sorts the container by the member x, or  (although sort_member_func does this for you, see below)
//
//				std::find_if(cont.begin(), cont.end(), unary_select_member_func(std::bind2nd(std::equal_to<int>(), 1), &T::Get_x));
//
//			Finds an element whose member x is 1  (although find_if_member_func does this for you, see below)
//


// constructs...
template<class F, class T, class U> struct select_member_2t : std::binary_function<T, T, F::result_type>
{
	select_member_2t(const F &f, U T::*object) : f(f), object(object) {}

	F::result_type operator()(const T& a,						const T& b)							const {		return f(a.*object,	b.*object);	}	

	F f;
	U T::*object;
};
template<class F, class T, class U> struct select_member_1t : std::unary_function<T, F::result_type>
{
	select_member_1t(const F &f, U T::*object) : f(f), object(object) {}

	result_type operator()(const T& a)	const {		return f(a.*object);	}

	F f;
	U T::*object;
};

template<class F, class T, class U> struct select_member_func_2t : std::binary_function<T, T, F::result_type>
{
	typedef U (T::*get_object_func_type)() const;

	select_member_func_2t(const F &f, get_object_func_type get_object) : f(f), get_object(get_object) {}

	F::result_type operator()(const T& a,						const T& b)							const {		return f((a.*get_object)(),	(b.*get_object)());	}

	F f;
	get_object_func_type get_object;
};
template<class F, class T, class U> struct select_member_func_1t : std::unary_function<T, F::result_type>
{
	typedef U (T::*get_object_func_type)() const;

	select_member_func_1t(const F &f, get_object_func_type get_object) : f(f), get_object(get_object) {}

	result_type operator()(const T& a)	const	{	return f( (a.*get_object)() );	}

	F f;
	get_object_func_type get_object;
};

// these are what you actually call...
template<class F, class T, class U> select_member_2t<F, T, U> binary_select_member(const F& f, U T::*object) 
{
	return select_member_2t<F, T, U>(f, object);
}

template<class F, class T, class U> select_member_1t<F, T, U> unary_select_member(const F& f, U T::*object) 
{
	return select_member_1t<F, T, U>(f, object);
}

template<class F, class T, class U> select_member_func_2t<F, T, U> binary_select_member_func(const F& f, U (T::*get_object)() const) 
{
	return select_member_func_2t<F, T, U>(f, get_object);
}

template<class F, class T, class U> select_member_func_1t<F, T, U> unary_select_member_func(const F& f, U (T::*get_object)() const) 
{
	return select_member_func_1t<F, T, U>(f, get_object);
}

// 


//  function object adapter - find_if_member, less_member, find_if_member_func, less_member_func
//
//	function objects designed to be passed to std::sort and std::find_if (or other algorithms) that allow you sort a container or find an object 
//	in a container, by testing on a specific member
//
//	e.g.		struct T { int x, y;	};
//				std::vector<T>	cont;
//				 ...
//				std::sort(cont.begin(), cont.end(), less_member(&T::x));
//
//			Sorts the container by the member x, or
//
//				std::find_if(cont.begin(), cont.end(), equal_to_member(1, &T::x));
//
//			Finds an element whose member x is 1
//
//	Similarly, both adapters are available with _func versions - these allow you to use the value returned from a function
//
//	e.g.		class T { int x; public: int Get_x() };
//				std::vector<T>	cont;
//				 ...
//				std::sort(cont.begin(), cont.end(), less_member_func(&T::Get_x));
//
//			Sorts the container by the member x, or
//
//				std::find_if(cont.begin(), cont.end(), equal_to_member_func(1, &T::Get_x));
//
//			Finds an element whose member x is 1

template<class T, class U> select_member_1t<std::binder2nd<std::equal_to<U> >, T, U> equal_to_member(U look_for, U T::*member)
{
	return unary_select_member(std::bind2nd(std::equal_to<U>(), look_for), member);
}

template<class T, class U> select_member_func_1t<std::binder2nd<std::equal_to<U> >, T, U> equal_to_member_func(U look_for, U (T::*get_member)() const)
{
	return unary_select_member_func(std::bind2nd(std::equal_to<U>(), look_for), get_member);
}

template<class T, class U> select_member_2t<std::less<U>, T, U> less_member(U T::*member)
{
	return binary_select_member(std::less<U>(), member);
}

template<class T, class U> select_member_func_2t<std::less<U>, T, U> less_member_func(U (T::*get_member)() const)
{
	return binary_select_member_func(std::less<U>(), get_member);
}

#endif // !defined(helper_binders_h)