multi_index ordered_non_unique Sınıfı

Giriş
Şu satırı dahil ederiz.

#include <boost/multi_index/ordered_index.hpp>

std::multimap gibidir.

Kolay kullanım için şu satırı dahil ederiz.

namespace mi = boost::multi_index;

Tanımlama - identity

Şöyle yaparız.

mi::multi_index_container<
  std::string,
  mi::indexed_by<
    mi::ordered_non_unique< mi::identity<std::string> >,
  ... 
  >
>;

Şöyle yaparız.

mi::multi_index_container<
  size_t,
  mi::indexed_by<
    mi::ordered_non_unique< mi::identity<size_t>, IndexComparator >,
  ...
  >
>;

Tanımlama - composite key of member
Şöyle yaparız.

typedef multi_index_container<
  Employee, 
  indexed_by<
    ordered_non_unique<
      composite_key<
        Employee,
        member<Employee, int, &Employee::id>,
        member<Employee, int, &Employee::salary>
      >
    >
  > 
> EmployeeSet;

Tanımlama - member - Üye Alan
Şöyle yaparız. Burada tag yerinde tanımlanıyor. Normalde tag struct'ı dışarıda tanımlamak daha iyi.

struct 
Relation { int data_id, account_id; };

boost::multi_index_container<
  Relation, 
  bmi::indexed_by<
    bmi::ordered_non_unique<
      bmi::tag<struct by_account>,
      bmi::member<Relation, int, &Relation::account_id>
    >
  >
>;

Tanımlama - member function - Üye metod
Şu satırı dahil ederiz.

#include <boost/multi_index/mem_fun.hpp>

Key extractor olarak beliritlen getter metodu kullanır.
Örnek
Şöyle yaparız.

struct Relation { 

  int data_id() const    { return ...; }
  int account_id() const { return ...; }
};

boost::multi_index_container<
  Relation, 
  bmi::indexed_by<
    bmi::ordered_non_unique<
      bmi::tag<struct by_account>,
      bmi::const_mem_fun<Relation, int, &Relation::account_id>
    >
  >
>;

Örnek
Elimizde şöyle bir kod olsun

class employee {
  int id;
  std::string name;

public:
  employee(int id, const std::string &name) : id(id), name(name) {}

  bool operator<(const employee &e) const { return id < e.id; }

  int getId() const { return id; }
  std::string getName() const { return name; }
};

Şöyle yaparız.

#include <boost/multi_index/mem_fun.hpp>
#include <boost/multi_index/ordered_index.hpp>
#include <boost/multi_index_container.hpp>

namespace bmi = boost::multi_index;
typedef bmi::multi_index_container<
  employee,
 bmi::indexed_by<
  bmi::ordered_unique<bmi::identity<employee> >,
  bmi::ordered_non_unique<bmi::const_mem_fun<employee, std::string, &employee::getName> >
> > employee_set;

equal_range metodu
Elimizde şöyle bir indeks olsun.

struct X {
    int i; //  = [] { static int gen = 0; return ++gen; }();
    std::string name;
};

namespace bmi = boost::multi_index;
typedef boost::multi_index_container<X,
  bmi::indexed_by<
    bmi::ordered_non_unique<
      bmi::tag<struct by_i>,
      bmi::composite_key<X,
        bmi::member<X, int, &X::i>,
        bmi::member<X, std::string, &X::name>
      >
    >
  >
> OrderSet;

Şöyle yaparız.

OrderSet orderSet_ {
  { 1, "one" }, { 1, "two" }, { 2, "three" }, { 3, "four" }, { 2, "five" }
};


auto const range = orderSet_/*.get<0>()*/.equal_range(boost::make_tuple(2));

for (auto& el : boost::make_iterator_range(range))
  std::cout << el.i << "," << el.name << "; ";

lower_bound metodu
Şöyle yaparız

auto it = index.lower_bound (3, cmp);

modify metodu
Elimizde şöyle bir kod olsun

struct Person
{
    string FamilyName;
    string PersonalName;
  
};

typedef boost::multi_index_container
<
    Person,
    indexed_by<
        ordered_non_unique<member<Person, string, &Person::FamilyName>>,
        ordered_non_unique<member<Person, string, &Person::PersonalName>>
    >
>
PersonList;

Değiştirmek istediğimiz nesneyi buluruz.

string toFind = "Fred";
string toReplace = "Barney";

PersonList::nth_index<1>::type::const_iterator itr1( people.get<1>().find(toFind) );

Şöyle yaparız.

people.get<1>().modify(itr1, [&](Person &e){ e.PersonalName = toReplace; });

upper_bound metodu
Şöyle yaparız.

auto it = contaier.upper_bound("baz");