How to use map::equal_range without a copy of the object? - c++

Question

I have a performance-sensitive function which uses a map<string, ...> to store some data.
I need to be able to look up values with any substring of some other string as the key, without creating an intermediate string (i.e., the goal is to prevent a heap allocation from happening merely because I want to look something up).
The obvious solution is to hold two separate data structures (perhaps with another map on the side, to map from some key to to each string) -- one for the strings, and one for references to those strings.
But I'm wondering, is there a better way to do this with just a map alone, or do I need another data structure? I'd like to avoid creating too many extra indirections if possible.

Answer 1

Sorry if I misunderstood, but would your problem be solved if you could use a "substring view" of the query string to search the multi-map, instead of an ordinary std::string object?
In that case something along the lines below would work (using C++11-based coding):
Define a substring-view object type. It is constructed from a string and (from,to) offsets, but does not make a copy of the substring:
class substrview
{
std::string::const_iterator _from;
std::string::const_iterator _to;
public:
substrview(
const std::string &s,
const std::size_t from,
const std::size_t to)
: _from(s.begin()+from), _to(s.begin()+to)
{ }
std::string::const_iterator begin() const
{ return _from; }
std::string::const_iterator end() const
{ return _to; }
};
In order to search the multi-map using the substring view, I suggest using the std::lower_bound and std::upper_bound methods from <algorithm>:
int main()
{
std::multimap<std::string,int> map {
{ "hello" , 1 },
{ "world" , 2 },
{ "foo" , 3 },
{ "foobar" , 4 },
{ "foo" , 5 },
};
std::string query { "barfoo" };
/* Search for all suffixes of "barfoo", one after the other: */
for (std::size_t i = 0 ; i < query.size() ; ++i) {
substrview subquery { query,i,query.size() };
auto found_from = std::lower_bound(begin(map),end(map),subquery,cmpL);
auto found_to = std::upper_bound(begin(map),end(map),subquery,cmpU);
/* Now [found_from,found_to) is the match range in the multi-map.
Printing the matches: */
while (found_from != found_to) {
std::cout << found_from->first << ", " << found_from->second << '\n';
++found_from;
}
}
}
For this to work, we only need to define the comparison operators cmpL and cmpU (one for lower_bound, the other for upper_bound – we need two because the comparison is assymetric: comparing a multi-map entry to a substringview in cmpL, and comparing a substringview to a multi-map entry in cmpU):
inline bool cmpL(
const std::pair<std::string,int> &entry,
const substrview &val)
{
return std::lexicographical_compare
(entry.first.begin(),entry.first.end(),val.begin(),val.end());
}
inline bool cmpU(
const substrview &val,
const std::pair<std::string,int> &entry)
{
return std::lexicographical_compare
(val.begin(),val.end(),entry.first.begin(),entry.first.end());
}
Working gist of the complete code: https://gist.github.com/4070189

Answer 2

You need a string_ref type which participates in the < relation with std::string. In the TS n3442, Jeffrey Yaskin proposes introducing a string_ref type influenced by Google's StringPiece and llvm's StringRef. If you can use either of those then you're pretty much done; otherwise writing your own to the proposed interface should be fairly easy, especially as you only need a subset of the functionality.
Note that if you have an implicit constructor from std::string:
string_ref(const std::string &s): begin(s.begin()), end(s.end()) {}
then the < relation with std::string comes for free.