Re: how to make a simple generic function... parameterized by
collection & value
{ This thread has turned into a debugging effort of a specific piece
of code, which limits its relevance to the general C++ community.
Please keep that in mind when replying -mod }
Am 19.05.2012 10:28, schrieb Mark Summerfield:
I tried what you suggested but got the same errors.
template<typename T>
struct identity { typedef T type; };
template<typename T>
using NonDeduced = typename identity<T>::type;
template<typename T>
using Validator = std::function<T(const std::string)>;
template<typename C>
Validator<typename C::value_type>
makeSetValidator(const C&validItems,
NonDeduced<typename C::value_type(*)(const std::string)> validate)
{
return [=](const std::string s)->typename C::value_type{
const auto x = validate(s);
if (std::find(std::begin(validItems), std::end(validItems), x)
!= std::end(validItems))
return x;
throw ValueError("Invalid item '" + s + "'");
};
}
template<typename T>
T validate(const std::string s) { ... }
At the call site I tried:
auto v = makeSetValidator<int>(std::set<int>{-4, 8, 31},
validate<int>);
auto v = makeSetValidator(std::set<int>{-4, 8, 31}, validate<int>);
auto v = makeSetValidator<int>(std::set<int>{-4, 8, 31}, validate);
auto v = makeSetValidator(std::set<int>{-4, 8, 31}, validate);
None of which would compile.
The first and third form cannot possibly be well-formed for reasons
that I explained in my very first reply in this thread. The other
forms should work. Since you do not provide a complete program, but
only snippets there might be several reasons for the failure (include
that the compiler version you used cannot properly handle some of the
new C++11 constructs). Except from the lambda expression, it is easy
to make your code a fully C++03 compatible program like so:
#include <string>
#include <set>
template<typename T>
struct identity { typedef T type; };
struct ValueError { ValueError(const std::string& what) {} };
template<typename T>
struct function;
template<typename R, typename T>
struct function<R(T)>
{
template<typename F>
function(F){}
};
template<typename C>
function<typename C::value_type(const std::string)>
makeSetValidator(const C &validItems,
typename identity<typename C::value_type(*)(const
std::string)>::type validate)
{
return function<typename C::value_type(const std::string)>(validate);
}
template<typename T>
T validate(const std::string s) { return T(); }
int main()
{
makeSetValidator(std::set<int>(), validate<int>);
makeSetValidator(std::set<int>(), validate);
}
This compiles on every compiler I tested. I recommend to start with
this and to increase the functionality step-wise to the point where it
does no longer work, then try to isolate the actual problem.
HTH & Greetings from Bremen,
Daniel Kr?gler
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]