查找嵌套升壓的multi_index_container

Question

考慮下面的代碼

struct VersionData 
{ 
    VersionData(); 
    VersionData(VersionData&& rhs); 
    int  m_versionId; 
    int  m_weight; 
    int  m_pId; 
    bool m_hdi; 
}; 

struct VersionId{}; 

typedef boost::multi_index_container< 
    VersionData, 
    bmi::indexed_by< 
     bmi::ordered_non_unique< 
      bmi::tag<VersionId>, 
      bmi::member<VersionData, int, &VersionData::m_versionId> 
     > 
    > 
> VersionDataContainer; 

struct VersionsData 
{ 
    VersionsData(); 
    VersionsData(VersionsData&& rhs); 
    int m_sdGroupId; 
    int m_retId; 
    VersionDataContainer m_versionData; 
}; 

struct mvKey{}; 

typedef boost::multi_index_container< 
    VersionsData, 
    bmi::indexed_by< 
    bmi::ordered_unique< 
      bmi::tag<mvKey>, 
      bmi::composite_key< 
       VersionsData, 
       bmi::member<VersionsData,int, &VersionsData::m_subdeliveryGroupId>, 
       bmi::member<VersionsData,int, &VersionsData::m_retargetingId> 
      > 
     > 
    > 
> mvDataContainer; 

mvDataContainer m_data; 

的意圖是利用mvDataContainer但在某些情況下，我需要VersionData所有VersionsData查找組合鍵來查找。類似於m_data.get < mvKey> .equal_range（make_tuple（ignore，ignore，ignore））。get < VersionId> .equal_range（123456）;
第一個問題，它是可以實現的嗎？
其次，這是使用嵌套multi_index_containers的正確方法嗎？任何性能影響/收益？

Answer 1

因此，我們確實，而是採用嵌套容器，像（live on Coliru）

你可以/應該執行它作爲一個單一/表/（畢竟，這是與幾個指標表） ：

Live On Coliru

#include <boost/multi_index_container.hpp> 
#include <boost/multi_index/ordered_index.hpp> 
#include <boost/multi_index/member.hpp> 
#include <boost/multi_index/composite_key.hpp> 

namespace bmi = boost::multi_index; 

struct VersionRecord { 
    int m_subdeliveryGroupId; 
    int m_retargetingId; 
    int m_versionId; 
    int m_weight; 
    int m_pId; 
    bool m_hdi; 

    friend std::ostream& operator<<(std::ostream& os, VersionRecord const& record) { 
     return os << "{ " << record.m_subdeliveryGroupId << " " << record.m_retargetingId << " " 
      << record.m_versionId << " " << record.m_weight << " " << record.m_pId << " " << record.m_hdi << " }"; 
    } 
}; 

typedef boost::multi_index_container< 
    VersionRecord, 
    bmi::indexed_by< 
     bmi::ordered_unique< 
      bmi::tag<struct mvKey>, 
      bmi::composite_key< 
       VersionRecord, 
       bmi::member<VersionRecord,int, &VersionRecord::m_subdeliveryGroupId>, 
       bmi::member<VersionRecord,int, &VersionRecord::m_retargetingId> 
      > 
     >, 
     bmi::ordered_non_unique< 
      bmi::tag<struct VersionId>, 
      bmi::member<VersionRecord, int, &VersionRecord::m_versionId> 
     > 
    > 
> VersionTable; 

#include <iostream> 
#include <boost/range/iterator_range.hpp> 

int main() { 

    auto table = VersionTable { 
     { 21, 10,    1, 100, 123, false }, 
     { 9, 27,    2, 90, 123, false }, 
     { 12, 25,    3, 110, 123, true }, 
     { 10, 33, /*version 8:*/ 8, 80, 123, false }, 
     { 4, 38,    5, 101, 124, false }, 
     { 33, 7,     6, 91, 124, false }, 
     { 34, 27,    7, 111, 124, true }, 
     { 9, 11, /*version 8:*/ 8, 81, 124, false }, 
     { 0, 12,    9, 99, 125, false }, 
     { 35, 39, /*version 8:*/ 8, 89, 125, false }, 
     { 15, 15,    11, 109, 125, true }, 
     { 25, 32, /*version 8:*/ 8, 79, 125, false }, 
    }; 

    // debug table output 
    assert(table.size()==12); 
    for (auto& record : table) std::cout << record << "\n"; 

    // so now you can do: 
    auto& idx = table.get<VersionId>(); 

    std::cout << "---\nQuerying for version id 8:\n"; 
    for (auto& record : boost::make_iterator_range(idx.equal_range(8))) 
     std::cout << record << "\n"; 
} 

它打印：

{ 0 12 9 99 125 0 } 
{ 4 38 5 101 124 0 } 
{ 9 11 8 81 124 0 } 
{ 9 27 2 90 123 0 } 
{ 10 33 8 80 123 0 } 
{ 12 25 3 110 123 1 } 
{ 15 15 11 109 125 1 } 
{ 21 10 1 100 123 0 } 
{ 25 32 8 79 125 0 } 
{ 33 7 6 91 124 0 } 
{ 34 27 7 111 124 1 } 
{ 35 39 8 89 125 0 } 
--- 
Querying for version id 8: 
{ 25 32 8 79 125 0 } 
{ 35 39 8 89 125 0 } 
{ 10 33 8 80 123 0 } 
{ 9 11 8 81 124 0 } 

或者，您可以bolt an intrusive container上的VersionsData記錄頂部。然而，這會使設計複雜化（您必須使用auto_unlink節點掛鉤（犧牲線程安全控制），或者您必須確保容器始終保持同步。

Answer 2

除了另一個建議使用單個容器的答案爲整個表，這裏的基礎上Boost Intrusive multiset

的想法看它Live On Coliru

#include <boost/multi_index_container.hpp> 
#include <boost/multi_index/ordered_index.hpp> 
#include <boost/multi_index/member.hpp> 
#include <boost/multi_index/composite_key.hpp> 

// for intrusive multiset 
#include <boost/intrusive/set.hpp> 
#include <boost/range/iterator_range.hpp> 
#include <iostream> 

namespace bmi = boost::multi_index; 
namespace bi = boost::intrusive; 

struct VersionData : bi::set_base_hook<bi::link_mode<bi::auto_unlink> > { 
    VersionData(int versionId, int weight=0, int pId=0, bool hdi=false) : 
     m_versionId(versionId), m_weight(weight), m_pId(pId), m_hdi(hdi) { } 

    int  m_versionId; 
    int  m_weight; 
    int  m_pId; 
    bool m_hdi; 

    friend std::ostream& operator<<(std::ostream& os, VersionData const& vd) { 
     return os << "{ " << vd.m_versionId << " " << vd.m_weight << " " << vd.m_pId << " " << vd.m_hdi << " }"; 
    } 

    struct ById { 
     bool operator()(VersionData const& a, VersionData const& b) const { return a.m_versionId < b.m_versionId; } 
    }; 
}; 

typedef bi::multiset<VersionData, bi::constant_time_size<false>, bi::compare<VersionData::ById> > VersionIndex; 

typedef boost::multi_index_container< 
    VersionData, 
    bmi::indexed_by< 
     bmi::ordered_non_unique< 
      bmi::tag<struct VersionId>, 
      bmi::member<VersionData, int, &VersionData::m_versionId> 
     > 
    > 
> VersionDataContainer; 

struct VersionsData 
{ 
    int m_subdeliveryGroupId; 
    int m_retargetingId; 

    VersionDataContainer m_versionData; 
}; 

typedef boost::multi_index_container< 
    VersionsData, 
    bmi::indexed_by< 
    bmi::ordered_unique< 
      bmi::tag<struct mvKey>, 
      bmi::composite_key< 
       VersionsData, 
       bmi::member<VersionsData,int, &VersionsData::m_subdeliveryGroupId>, 
       bmi::member<VersionsData,int, &VersionsData::m_retargetingId> 
      > 
     > 
    > 
> mvDataContainer; 

void insert(
     mvDataContainer& into, VersionIndex& global_version_index, 
     int subdeliveryGroupId, int retargetingId, int 
     versionId, int weight, int pId, bool hdi) 
{ 
    auto& mainIdx = into.get<mvKey>(); 
    auto insertion = mainIdx.insert(VersionsData { subdeliveryGroupId, retargetingId, VersionDataContainer {} }); 
    mainIdx.modify(insertion.first, [&](VersionsData& record) { 
      auto insertion = record.m_versionData.insert(VersionData { versionId, weight, pId, hdi }); 
      global_version_index.insert(const_cast<VersionData&>(*insertion.first)); 
    }); 
} 

int main() { 

    VersionIndex global_version_index; 
    mvDataContainer table; 

    insert(table, global_version_index, 21, 10,    1, 100, 123, false); 
    insert(table, global_version_index, 9, 27,    2, 90, 123, false); 
    insert(table, global_version_index, 12, 25,    3, 110, 123, true); 
    insert(table, global_version_index, 10, 33, /*version 8:*/ 8, 80, 123, false); 
    insert(table, global_version_index, 4, 38,    5, 101, 124, false); 
    insert(table, global_version_index, 33, 7,     6, 91, 124, false); 
    insert(table, global_version_index, 34, 27,    7, 111, 124, true); 
    insert(table, global_version_index, 9, 11, /*version 8:*/ 8, 81, 124, false); 
    insert(table, global_version_index, 0, 12,    9, 99, 125, false); 
    insert(table, global_version_index, 35, 39, /*version 8:*/ 8, 89, 125, false); 
    insert(table, global_version_index, 15, 15,    11, 109, 125, true); 
    insert(table, global_version_index, 25, 32, /*version 8:*/ 8, 79, 125, false); 

    // debug table output 
    assert(table.size()==12); 

    // so now you can do: 
    std::cout << "---\nQuerying for version id 8:\n"; 
    for (auto& record : boost::make_iterator_range(global_version_index.equal_range(8))) 
     std::cout << record << "\n"; 

    table.erase(table.find(boost::make_tuple(10,33))); // auto unlinks from global_version_index 

    std::cout << "---\nQuerying for version id 8:\n"; 
    for (auto& record : boost::make_iterator_range(global_version_index.equal_range(8))) 
     std::cout << record << "\n"; 
} 

打印：

--- 
Querying for version id 8: 
{ 8 80 123 0 } 
{ 8 81 124 0 } 
{ 8 89 125 0 } 
{ 8 79 125 0 } 
--- 
Querying for version id 8: 
{ 8 81 124 0 } 
{ 8 89 125 0 } 
{ 8 79 125 0 } 

Answer 3

這不是我最初問的確切答案，但是由於性能問題被提及，並且根據與@sehe的討論，這就是我發現的。使用boost :: flyweight
2）使用MIC而不是定製的容器，MIC在搜索簡單索引時可能會稍微慢一點（取決於測試場景），因此，但一旦你使用複合鍵（併爲你的定製數據結構實現類似的行爲），它比定製的DS稍快，速度也更快。我之前使用的定製速度更快的語句是錯誤的，因爲我使用的是來自boost 1.52的MIC，看起來像使用帶有字符串的組合鍵（比沒有字符串的組合鍵慢5個數量級）時出現錯誤。當切換到1.57時，一切開始按預期工作。

Tests on Coliru
有一個很好的索引，傢伙！:)