Question

Let’s say I’m using a map that uses three strings as a key. Here’s a quick example struct:

struct ExampleMapKey
{
 std::string key0;
 std::string key1;
 std::string key2;

 bool operator<(const ExampleMapKey& other) const
 {
  if (key0 < other.key0) return true;
  else if (key0 > other.key0) return false;

  if (key1 < other.key1) return true;
  else if (key1 > other.key1) return false;

  return key2 < other.key2;
 }
}

Now, this works fine until I decide I want to use lower_bound and upper_bound. If I want to find the range of values formed by any key0, any key1 starting with “ab”, and any key2 starting with “cd”, using those 2 functions with ExampleMapKey("", "ab", "cd") and ExampleMapKey("", "ac", "ce") respectively will have me iterating through keys that don’t fulfill my requirements. Or will I miss keys that do? Either way, it’s wrong.

It seems what I need is a data structure that explicitly indexes by each key, and will also allow me to perform potentially complicated lower_bound and upper_bound iterations. Is there such a thing? I’m not necessarily using strings, nor am I limited to only 3 keys, so it needs to be STL-style or similarly generic.

Answer 1

1. Boost Multi-index Containers Library can be of help.

   Update: After rereading your question, I think you may have to do what is taught in db classes; you would have to use one of the indices to create a temporary result, and prune that result, based on your second constraint (alternatively, you can run each constraint on each index, joining the results). Boost Multi-index Containers will only allow lookup on one index at a time AFAIK.

2. For the particular type of query that you asked, you might be able to come up with a very specialized data structure that can help, by adding indices on partitions of indices. That is for example, you take the 2nd index, split it in half, rewrite a 3rd index for the first half, and for the 2nd half. Then you split each half and repeat. This way, you can select a section of the 2nd index, and then subsequently select a part of the 3rd index that is within (approximately) that part of the 2nd index. But I don’t know of any library that does this.

3. Another approach might be some sort of multi-dimensional data structure, though I am not familiar with using such a structure with non-numeric keys. For example, imagine your keys were integers, you could use a 3D kd-tree or other spatial index, and query for a cubic range. For example: (using libssrckdtree, seems it might work with strings too):

Codes for (3):

#include <ssrc/spatial/kd_tree.h>

#include <cstdlib>
#include <ctime>
#include <iostream>
#include <algorithm>
#include <cassert>

#include <string>

typedef std::array<std::string, 3> Point;

typedef ssrc::spatial::kd_tree<Point, Point> Tree;

int main()
{
  Tree tree;

  Point point = {{"any1","aa1","cc1"}};
  tree[point] = point;

  point = {{"any2","ab1","cc1"}};
  tree[point] = point;

  point = {{"any3","ab1","cd1"}};
  tree[point] = point;
  point = {{"any4","ab1","cd2"}};
  tree[point] = point;
  point = {{"any5","ab1","cd3"}};
  tree[point] = point;


  point = {{"any22","ac1","cc1"}};
  tree[point] = point;

  point = {{"any33","ac1","cd1"}};
  tree[point] = point;
  point = {{"any44","ac1","cd2"}};
  tree[point] = point;
  point = {{"any55","ac1","cd3"}};
  tree[point] = point;


  point = {{"any6","aa1","cd2"}};
  tree[point] = point;
  point = {{"any7","aa1","cd3"}};
  tree[point] = point;

  Point lower{ { "any0", "ab", "cd" } }, upper{ { "any9", "ac", "cd2" } };

  for(Tree::const_iterator it = tree.begin(lower, upper), end = tree.end();
      it != end; ++it)
  {
    Point point = it->first;
    Point value = it->second;
    std::cout << point[0] << ", " << point[1] << ", " << point[2] << std::endl;
  }


  return 0;
}

Output:

any3, ab1, cd1
any4, ab1, cd2