Find an element of vector which is presented in the map - boost

Question

I need to find an element of vector which is presented in map. Hard part is that vector consists of structures, so you should call member function to extract value form the structure first to compare it to the map elements.
So, with for cycle it's pretty easy:
vector<A>::iterator it;
for( it = vec.begin(); it != vec.end(); ++it )
{
if( mp.count( it->getKey() ) )
{
break;
}
}
My question: is there any way to do it in one line, something like
//this doesn't work as count accepts key_type
vector<A>::iterator it = find_if( vec.begin(), vec.end(), boost::bind( &map<string, string>::count, mp, boost::bind( &A::getKey, _1 ) )) != 0);
Full example, to test
#include <string>
#include <vector>
#include <iostream>
#include <algorithm>
#include <boost/bind.hpp>
#include <boost/assign.hpp>
using namespace std;
class A{
public:
A( const std::string& key )
: key( key ) {}
std::string getKey(){ return key; }
private:
std::string key;
};
int main(int argc, const char *argv[]) {
map<string, string> mp = boost::assign::map_list_of( "Key1", "Val1" ) ( "Key2", "Val2" ) ( "Key3", "Val3" );
vector<A> vec = boost::assign::list_of( "AAA" ) ( "Key2" ) ( "BBB" );
// vector<A>::iterator it = find_if( vec.begin(), vec.end(), boost::bind( &map<string, string>::count, mp, boost::bind( &A::getKey, _1 ) )) != 0);
vector<A>::iterator it;
for( it = vec.begin(); it != vec.end(); ++it )
{
if( mp.count( it->getKey() ) )
{
break;
}
}
cout << ( it != vec.end() ? "found" : "not found" ) << endl;
return 0;
}
Thanks in advance

Answer 1

Your solution was close, there is just one closing parenthesis too many. Placing each parenthesis on a newline with indenting for each level emphasizes the invalid parenthesis:
vector<A>::iterator it = find_if
(
vec.begin(), vec.end(), boost::bind
(
&map<string, string>::count, &mp, boost::bind
(
&A::getKey, _1
)
)
) // one too many
!= 0);
In its simplest form, the line becomes iterator = find_if(...) != 0), which will cause the compiler to fail on either:
Not being able to find operator!=(iterator, int).
The ) token in != 0).
With correct parentheses, != 0 uses an operator overload provided by boost::bind. The line would look like:
vector<A>::iterator it = find_if(vec.begin(), vec.end(),
boost::bind(&map<string, string>::count, &mp,
boost::bind(&A::getKey, _1)) != 0);
However, consider the readability of such a simple operation. If a simple for loop is not generic and reusable enough, then consider hiding it within a convenience function:
template <typename InputIterator,
typename C,
typename Fn>
InputIterator find_if_contains(
InputIterator first,
InputIterator last,
const C& container,
Fn fn)
{
while (first != last)
{
if (0 != container.count(fn(*first))) return first;
++first;
}
return last;
}
...
vector<A>::iterator it = find_if_contains(
vec.begin(), vec.end(),
mp, boost::bind(&A::getKey, _1)
);
Otherwise, a custom predicate type may enhance readability while providing some extra flexibility for reuse with different types. For example, consider the following predicate type that works for various types of associative containers:
template <typename C,
typename Fn>
struct contains_predicate
{
contains_predicate(const C& container, Fn fn)
: container_(&container), fn_(fn)
{}
template <typename T>
bool operator()(T& t)
{
return 0 != container_->count(fn_(t));
}
const C* container_;
Fn fn_;
};
template <typename C,
typename Fn>
contains_predicate<C, Fn>
contains(const C& container, Fn fn)
{
return contains_predicate<C, Fn>(container, fn);
}
...
vector<A>::iterator it = find_if(vec.begin(), vec.end(),
contains(mp, boost::bind(&A::getKey, _1)));

Answer 2

In C++11, use a lambda:
find_if(vec.begin(), vec.end(), [&](A const & a){return mp.count(a.getKey());});
But since you're using Boost.Assign rather than uniform initialisation, perhaps you can't do that. I'm afraid I don't know how to construct a functor like that using bind alone.