#include <iostream>

template <typename T, typename Other>
bool is_one_of(T lhs, Other rhs) {
  return lhs == rhs;
}

template <typename T, typename First, typename... Rest>
bool is_one_of(T lhs, First rh, Rest... rhs) {
  return lhs == rh || is_one_of(lhs, rhs...);
}

int main() {
  if (is_one_of(1, 3, 4, 1, 2, 5)) 
    std::cout << "yay" << std::endl;

  if (is_one_of<std::string>("foo", "bar", "baz", "foo")) 
    std::cout << "yay 2" << std::endl;
}

Vanadium fucked around with this message at 22:33 on Aug 27, 2008

Flobbster fucked around with this message at 22:48 on Aug 27, 2008

// Forward declaration
template <typename... Values>
class any_of_comparator;

// Base case
template <typename First>
class any_of_comparator<First>
{
private:
	const First& first;
	
public:
	any_of_comparator(const First& _f) : first(_f) { }
	
	template <typename T>
	bool not_contains(const T& value) const
	{
		return value != first;
	}

	template <typename T>
	bool contains(const T& value) const
	{
		return value == first;
	}
};

// Recursive case
template <typename First, typename... Rest>
class any_of_comparator<First, Rest...> : private any_of_comparator<Rest...>
{
private:
	const First& first;

public:
	any_of_comparator(const First& _f, const Rest&... _r) :
		first(_f), any_of_comparator<Rest...>(_r...)
	{
	}

	template <typename T>
	bool not_contains(const T& value) const
	{
		return (value != first) && any_of_comparator<Rest...>::not_contains(value);
	}

	template <typename T>
	bool contains(const T& value) const
	{
		return (value == first) || any_of_comparator<Rest...>::contains(value);
	}
};

// The functional form is required so that the compiler will deduce the template types
// (which it won't do if we left this out and tried to use the constructor for the
// above class instead)
template <typename... Values>
any_of_comparator<Values...> any_of(const Values&... values)
{
	return any_of_comparator<Values...>(values...);
}

template <typename T, typename... Values>
bool operator==(const T& lhs, const any_of_comparator<Values...>& rhs)
{
	return rhs.contains(lhs);
}

template <typename T, typename... Values>
bool operator!=(const T& lhs, const any_of_comparator<Values...>& rhs)
{
	return rhs.not_contains(lhs);
}

// Try with constants. The following lines of code both generate the exact same assembly:
//     i == any_of(1, 2, 3, 4, 5)
//     (i == 1 || i == 2 || i == 3 || i == 4 || i == 5)
	movl	-28(%ebp), %eax
	cmpl	$1, %eax
	je	L4
	cmpl	$2, %eax
	je	L4
	cmpl	$3, %eax
	je	L4
	cmpl	$4, %eax
	je	L4
	cmpl	$5, %eax
	sete	%dl
	jmp	L5
	.align 4,0x90
L4:
	movl	$1, %edx

// Try with variables. The following lines of code both generate the exact same assembly:
//     i != any_of(j, k, l)
//     (i != j && i != k && i != l)
	cmpl	-32(%ebp), %eax
	je	L20
	cmpl	-36(%ebp), %eax
	je	L20
	cmpl	-40(%ebp), %eax
	setne	%al
	jmp	L21
	.align 4,0x90
L20:
	xorl	%eax, %eax

Flobbster fucked around with this message at 00:55 on Aug 28, 2008

#include <iostream>
#include <string>

template<typename... ArgsT>
struct any_impl;

template<typename FirstT>
struct any_impl<FirstT> {
  any_impl(FirstT first) : first(first) {}

  FirstT first;
};

template<typename FirstT, typename... OtherTs>
struct any_impl<FirstT, OtherTs...> {
  any_impl(FirstT first, OtherTs... others)
    : first(first), others(others...) {}

  FirstT first;
  any_impl<OtherTs...> others;
};

template<typename T, typename AnyT>
bool operator==(T obj, const any_impl<AnyT>& any) {
  return obj == any.first;
}

template<typename T, typename FirstT, typename... OtherTs>
bool operator==(T obj, const any_impl<FirstT, OtherTs...>& any) {
  return obj == any.first || obj == any.others;
}

template<typename T, typename AnyT>
bool operator==(const any_impl<AnyT>& any, T obj) {
  return obj == any.first;
}

template<typename T, typename FirstT, typename... OtherTs>
bool operator==(const any_impl<FirstT, OtherTs...>& any, T obj) {
  return any.first == obj || any.others == obj;
}

template<typename... ArgTs>
any_impl<ArgTs...> any_of(ArgTs... args) {
  return any_impl<ArgTs...>(args...);
}

// "trace" copying
template<typename T>
struct verbose {
  verbose(T val) : val(val) {
    std::cout << " verbose( " << val << " )" << std::endl;
  }

  verbose(const verbose& other) : val(other.val) {
    std::cout << " verbose([" << val << "])" << std::endl;
  }

  ~verbose() {
    std::cout << "~verbose( " << val << " )" << std::endl;
  }

  bool operator==(const verbose& other) const {
    std::cout
      << " verbose( " << val << " ) == verbose( "
      << other.val << " )" << std::endl;
    return val == other.val;
  }

  T val;
};

int main() {
  if (any_of(4, 3, 2, 1) == 1)
    std::cout << "yay" << std::endl;

  if (std::string("foo") == any_of("foo", "bar", "baz"))
    std::cout << "yay 2" << std::endl;

  verbose<int> v1(1), v2(2), v3(3), v4(4);
  if (any_of(v1, v2, v3, v4) == verbose<int>(5))
    std::cout << "yay 3" << std::endl;
}

Vanadium fucked around with this message at 00:44 on Aug 28, 2008