// Semantics Consulting's Tyr Library
// http://www.semantics.org
//
// Copyright (c) 2003 by Stephen C. Dewhurst
//
// Permission to use, copy, modify, distribute, and sell this software
// for any purpose is hereby granted without fee, provided that the above
// copyright notice appears in all copies and that both that copyright
// notice and this permission notice appear in supporting documentation.
// The author makes no representations about the suitability of this
// software for any purpose.  It is provided "as is" without express
// or implied warranty.

//	Described in Unfinished Business. C/C++ Users Journal Experts Forum, 21, 11 (November 2003).

#ifndef METAFUNCTION_H
#define METAFUNCTION_H

namespace Tyr {

//	These are adapters for compile-time predicates and comparitors,
//	similar in concept to STL function object adapters.
//
//	The convention used here is that a compile time predicate or comparitor
//	records its result as a nested value "r" that can be converted to bool.
//	Use of the adapters is a little clunky.  For example, to negate a predicate
//	called APred it's necessary to use the following syntax: Not1<APred>::Adapted.

//	Negate a unary predicate.
template <template <class> class X>
struct Not1 {
	template <class A>
	struct Adapted {
		enum { r = !X<A>::r };
	};
};

//	Negate a binary predicate (probably a comparitor).
template <template <class,class> class X>
struct Not2 {
	template <class A, class B>
	struct Adapted {
		enum { r = !X<A,B>::r };
	};
};

//	Or together two predicates.
template <template <class> class X, template <class> class Y>
struct Or1 {
	template <class A>
	struct Adapted {
		enum { r = X<A>::r || Y<A>::r };
	};
};

//	And together two predicates.
template <template <class> class X, template <class> class Y>
struct And1 {
	template <class A>
	struct Adapted {
		enum { r = X<A>::r && Y<A>::r };
	};
};

//	Or together two binary prdicates.
template <template <class,class> class X, template <class,class> class Y>
struct Or2 {
	template <class A, class B>
	struct Adapted {
		enum { r = X<A,B>::r || Y<A,B>::r };
	};
};

//	And together two binary predicates.
template <template <class,class> class X, template <class,class> class Y>
struct And2 {
	template <class A, class B>
	struct Adapted {
		enum { r = X<A,B>::r && Y<A,B>::r };
	};
};

//	Bind the first argument of a binary predicate to a fixed type in order
//	to produce a unary predicate.
template <template <class,class> class X, class A>
struct Bind1st {
	template <class B>
	struct Adapted {
		enum { r = X<A,B>::r };
	};
};

//	Bind the second arguemnt of a binary predicate to a fixed type in order
//	to produce a unary predicate.
template <template <class,class> class X, class B>
struct Bind2nd {
	template <class A>
	struct Adapted {
		enum { r = X<A,B>::r };
	};
};

} // namespace Tyr

#endif