Lucene：使用默认运算符= AND搜索多个字段(Lucene: Searching multiple fields with default operator = AND)

 借助于dyp的帮助，我可以使用以下技术解决此问题： 
 
 该解决方案不再使用函数指针，而是依赖于防止隐式转换的代理类： 
 
template <class Source>
struct NoConvert
{
  template <class Dest, class = typename std::enable_if<std::is_same<Source, Dest>::value>::type>
  operator Dest () const = delete;

  template <class Dest, class = typename std::enable_if<std::is_same<Source, Dest>::value>::type>
  operator Dest const & () const;
};

template <class> void func();

template <class A, class T, class U>
static auto test(int) -> decltype( func<A>( std::declval<T&>(), NoConvert<U>() ), std::true_type() );

template <class, class, class>
static std::false_type test(...);

template <class A, class T, class U>
static bool valid()
{
  return std::is_same<decltype(test<A, T, U>(0)), std::true_type>::value;
}
 
 可以像这样使用它： 
 
template <class T>
void func( B &, int const & );

template <class T>
void func( B &, std::string );

template <class T>
void func( A &, std::string const & );

std::cout << valid<A, B, int>() << std::endl;         // true
std::cout << valid<A, B, std::string>() << std::endl; // false
std::cout << valid<A, A, std::string>() << std::endl; // true
 
 通过使用NoConvert的转换运算符，您可以使用值，引用或常量引用来传递它。 
 
 例如，在当前使用中，当NoConvert<std::string>的转换运算符由NoConvert<std::string>的值参数触发时，两个重载都是有效的，因此存在不明确性，这意味着SFINAE将剔除并允许std::false_type测试通过。 在常量引用参数的情况下，常量引用超载具有优先权，并且正确地允许std::true_type测试超载传递。 
 
 该解决方案还依赖于使用ADL解析函数名称的功能，这对于函数指针方法来说是不可能的。 

I was able to solve this using the following technique, thanks to help from dyp:
 
This solution no longer makes use of function pointers and instead relies on a proxy class that prevents implicit conversion:
 
template <class Source>
struct NoConvert
{
  template <class Dest, class = typename std::enable_if<std::is_same<Source, Dest>::value>::type>
  operator Dest () const = delete;

  template <class Dest, class = typename std::enable_if<std::is_same<Source, Dest>::value>::type>
  operator Dest const & () const;
};

template <class> void func();

template <class A, class T, class U>
static auto test(int) -> decltype( func<A>( std::declval<T&>(), NoConvert<U>() ), std::true_type() );

template <class, class, class>
static std::false_type test(...);

template <class A, class T, class U>
static bool valid()
{
  return std::is_same<decltype(test<A, T, U>(0)), std::true_type>::value;
}
 
which can be used like:
 
template <class T>
void func( B &, int const & );

template <class T>
void func( B &, std::string );

template <class T>
void func( A &, std::string const & );

std::cout << valid<A, B, int>() << std::endl;         // true
std::cout << valid<A, B, std::string>() << std::endl; // false
std::cout << valid<A, A, std::string>() << std::endl; // true
 
By playing with the conversion operators inside of NoConvert, you can make this work with passing by value, reference, or constant reference. 
 
For example, in the current use, when the conversion operator for NoConvert<std::string> is triggered by a value parameter of std::string, both overloads are valid and thus there is ambiguity, meaning that SFINAE will cull this and allow the std::false_type test to pass. In the case of a constant reference parameter, the constant reference overload has precedence and properly allows the std::true_type test overload to pass.
 
This solution also relies on the ability to use ADL to resolve the name of the function, which was impossible with the function pointer approach.