#include <algorithm>
#include <boost/assign/list_of.hpp>
#include <boost/flyweight.hpp>
#include <boost/foreach.hpp>
#include <boost/multi_index_container.hpp>
#include <boost/multi_index/ordered_index.hpp>
#include <boost/multi_index/member.hpp>
#include <iostream>
#include <string>
#include <vector>

using namespace boost::assign;
using namespace boost::flyweights;
using namespace boost::multi_index;

typedef std::vector<std::string> path_t;
typedef flyweight<path_t> scenario_t;

struct entry
{
  entry(const scenario_t& scenario):scenario(scenario){}

  scenario_t scenario;
  // payload
};

typedef multi_index_container<
  entry,
  indexed_by<
    ordered_non_unique<member<entry,scenario_t,&entry::scenario> >
  >
> entry_container_t;

struct parent_t:scenario_t
{
  parent_t(const scenario_t& s):scenario_t(s){}
};

struct children
{
  bool operator()(const parent_t& p,const scenario_t& s)const
  {
    return std::lexicographical_compare(
      p.get().begin(),p.get().end(),
      s.get().begin(),s.get().begin()+std::min(p.get().size(),s.get().size()));
  }
  bool operator()(const scenario_t& s,const parent_t& p)const
  {
    return std::lexicographical_compare(
      s.get().begin(),s.get().begin()+std::min(p.get().size(),s.get().size()),
      p.get().begin(),p.get().end());
  }
};

void count_children(const entry_container_t& c,const scenario_t& s)
{
  std::cout<<"children in /";
  BOOST_FOREACH(const std::string& str,s.get()){
    std::cout<<str<<"/";
  }
  std::cout<<": "<<c.count(parent_t(s),children())<<"\n";
}

int main()
{
  entry_container_t c;
  scenario_t root,
             a=list_of("a"),
             b=list_of("b"),
             ac=list_of("a")("c"),
             ad=list_of("a")("d"),
             ace=list_of("a")("c")("e");
  // 1 entry in b, 2 entries in ad, 3 entries in ace
  c.insert(entry(b));
  c.insert(entry(ad));
  c.insert(entry(ad));
  c.insert(entry(ace));
  c.insert(entry(ace));
  c.insert(entry(ace));

  count_children(c,root);
  count_children(c,a);
  count_children(c,b);
  count_children(c,ac);
  count_children(c,ad);
  count_children(c,ace);
}