| /* Boost.MultiIndex example: complex searches and foreign keys. |
| * |
| * Copyright 2003-2008 Joaquin M Lopez Munoz. |
| * Distributed under the Boost Software License, Version 1.0. |
| * (See accompanying file LICENSE_1_0.txt or copy at |
| * http://www.boost.org/LICENSE_1_0.txt) |
| * |
| * See http://www.boost.org/libs/multi_index for library home page. |
| */ |
| |
| #if !defined(NDEBUG) |
| #define BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING |
| #define BOOST_MULTI_INDEX_ENABLE_SAFE_MODE |
| #endif |
| |
| #include <boost/multi_index_container.hpp> |
| #include <boost/multi_index/member.hpp> |
| #include <boost/multi_index/ordered_index.hpp> |
| #include <boost/tuple/tuple.hpp> |
| #include <iostream> |
| #include <string> |
| |
| using boost::multi_index_container; |
| using namespace boost::multi_index; |
| |
| /* This small utility that cascades two key extractors will be |
| * used througout the example. |
| */ |
| |
| template<class KeyExtractor1,class KeyExtractor2> |
| struct key_from_key |
| { |
| public: |
| typedef typename KeyExtractor1::result_type result_type; |
| |
| key_from_key( |
| const KeyExtractor1& key1_=KeyExtractor1(), |
| const KeyExtractor2& key2_=KeyExtractor2()): |
| key1(key1_),key2(key2_) |
| {} |
| |
| template<typename Arg> |
| result_type operator()(Arg& arg)const |
| { |
| return key1(key2(arg)); |
| } |
| |
| private: |
| KeyExtractor1 key1; |
| KeyExtractor2 key2; |
| }; |
| |
| /* tags for accessing several indices defined below */ |
| |
| struct model{}; |
| struct manufacturer{}; |
| struct price{}; |
| |
| /* a manufacturer struct just holds the name of the manufacturer */ |
| |
| struct car_manufacturer |
| { |
| std::string name; |
| |
| car_manufacturer(const std::string& name_):name(name_){} |
| }; |
| |
| /* car_model holds the model of car, its price and a pointer to the |
| * manufacturer. The pointer thing eliminates duplication of the same |
| * data among cars of the same manufacturer. |
| */ |
| |
| struct car_model |
| { |
| std::string model; |
| const car_manufacturer* manufacturer; |
| int price; |
| |
| car_model( |
| const std::string& model_,const car_manufacturer* manufacturer_,int price_): |
| model(model_),manufacturer(manufacturer_),price(price_) |
| {} |
| |
| friend std::ostream& operator<<(std::ostream& os,const car_model& c) |
| { |
| os<<c.manufacturer->name<<" "<<c.model<<" $"<<c.price<<std::endl; |
| return os; |
| } |
| }; |
| |
| /* see Compiler specifics: Use of member_offset for info on |
| * BOOST_MULTI_INDEX_MEMBER |
| */ |
| |
| /* Car manufacturers are stored in a multi_index_container with one single |
| * index on the name member. This is functionally equivalent to an std::set, |
| * though in this latter case we woud have to define a non-default comparison |
| * predicate (with multi_index_container, member<> does the work for us.) |
| */ |
| |
| typedef multi_index_container< |
| car_manufacturer, |
| indexed_by< |
| ordered_unique< |
| BOOST_MULTI_INDEX_MEMBER(car_manufacturer,std::string,name) |
| > |
| > |
| > car_manufacturer_table; |
| |
| /* Define a multi_index_container of car_models with following indices: |
| * - a unique index sorted by car_model::model, |
| * - a non-unique index sorted by car_model::manufacturer; note the |
| * non-standard manufacturer_extractor used. |
| * - a non-unique index sorted by car_model::price. |
| */ |
| |
| typedef multi_index_container< |
| car_model, |
| indexed_by< |
| ordered_unique< |
| tag<model>,BOOST_MULTI_INDEX_MEMBER(car_model,std::string,model) |
| >, |
| ordered_non_unique< |
| tag<manufacturer>, |
| key_from_key< |
| BOOST_MULTI_INDEX_MEMBER(car_manufacturer,const std::string,name), |
| BOOST_MULTI_INDEX_MEMBER( |
| car_model,const car_manufacturer *,manufacturer) |
| > |
| >, |
| ordered_non_unique< |
| tag<price>,BOOST_MULTI_INDEX_MEMBER(car_model,int,price) |
| > |
| > |
| > car_table; |
| |
| /* We call a *view* to a multi_index_container storing pointers instead of |
| * actual objects. These views are used in the complex search performed |
| * in the program. Resorting to multi_index of pointers eliminates |
| * unnecessary copying of objects, and provides us with an opportunity |
| * to show how BOOST_MULTI_INDEX_MEMBER can be used with pointer |
| * type elements. |
| * car_table_price_view indexes (pointers to) car_models by price. |
| */ |
| |
| typedef multi_index_container< |
| const car_model*, |
| indexed_by< |
| ordered_non_unique<BOOST_MULTI_INDEX_MEMBER(car_model,const int,price)> |
| > |
| > car_table_price_view; |
| |
| /* car_table_manufacturer_view indexes (pointers to) car_models by |
| * manufacturer |
| */ |
| |
| typedef multi_index_container< |
| const car_model*, |
| indexed_by< |
| ordered_non_unique< |
| key_from_key< |
| BOOST_MULTI_INDEX_MEMBER(car_manufacturer,const std::string,name), |
| BOOST_MULTI_INDEX_MEMBER( |
| car_model,const car_manufacturer * const,manufacturer) |
| > |
| > |
| > |
| > car_table_manufacturer_view; |
| |
| int main() |
| { |
| car_manufacturer_table cmt; |
| |
| /* Fill the car_manufacturer table and keep pointers to the |
| * elements inserted. |
| */ |
| |
| const car_manufacturer * cadillac= |
| &*(cmt.insert(car_manufacturer("Cadillac")).first); |
| const car_manufacturer * ford = |
| &*(cmt.insert(car_manufacturer("Ford")).first); |
| const car_manufacturer * bmw = |
| &*(cmt.insert(car_manufacturer("BMW")).first); |
| const car_manufacturer * audi = |
| &*(cmt.insert(car_manufacturer("Audi")).first); |
| |
| car_table ct; |
| |
| /* Fill the car_model_table. We use the previously initialized |
| * pointers to the elements of cmt. |
| */ |
| |
| ct.insert(car_model("XLR",cadillac,76200)); |
| ct.insert(car_model("SRX",cadillac,38690)); |
| ct.insert(car_model("CTS",cadillac,30695)); |
| ct.insert(car_model("Escalade",cadillac,54770)); |
| ct.insert(car_model("ESV",cadillac,57195)); |
| ct.insert(car_model("EXT",cadillac,52045)); |
| ct.insert(car_model("Deville",cadillac,45195)); |
| ct.insert(car_model("Seville",cadillac,46330)); |
| |
| ct.insert(car_model("ZX2",ford,15355)); |
| ct.insert(car_model("Thunderbird",ford,43995)); |
| ct.insert(car_model("Windstar",ford,35510)); |
| ct.insert(car_model("Focus",ford,19630)); |
| ct.insert(car_model("Taurus",ford,24290)); |
| ct.insert(car_model("Mustang",ford,39900)); |
| ct.insert(car_model("Crown Victoria",ford,30370)); |
| |
| ct.insert(car_model("325i",bmw,27800)); |
| ct.insert(car_model("545i",bmw,54300)); |
| ct.insert(car_model("745i",bmw,68500)); |
| ct.insert(car_model("M3 coupe",bmw,46500)); |
| ct.insert(car_model("Z4 roadster 3.0i",bmw,40250)); |
| ct.insert(car_model("X5 4.4i",bmw,49950)); |
| |
| ct.insert(car_model("A4 1.8T",audi,25940)); |
| ct.insert(car_model("TT Coupe",audi,33940)); |
| ct.insert(car_model("A6 3.0",audi,36640)); |
| ct.insert(car_model("Allroad quattro 2.7T",audi,40640)); |
| ct.insert(car_model("A8 L",audi,69190)); |
| |
| std::cout<<"enter a car manufacturer"<<std::endl; |
| std::string cm; |
| std::getline(std::cin,cm); |
| |
| /* check for manufacturer */ |
| |
| car_manufacturer_table::iterator icm=cmt.find(cm); |
| |
| if(icm==cmt.end()){ |
| std::cout<<"no such manufacturer in the table"<<std::endl; |
| return 0; |
| } |
| |
| std::cout<<"enter a minimum price"<<std::endl; |
| int min_price; |
| std::cin>>min_price; |
| std::cout<<"enter a maximum price"<<std::endl; |
| int max_price; |
| std::cin>>max_price; |
| |
| { |
| /* method 1 */ |
| |
| /* find all the cars for the manufacturer given */ |
| |
| boost::multi_index::index<car_table,manufacturer>::type::iterator ic0,ic1; |
| boost::tuples::tie(ic0,ic1)=get<manufacturer>(ct).equal_range(cm); |
| |
| /* construct a view (indexed by price) with these */ |
| |
| car_table_price_view ctpv; |
| while(ic0!=ic1){ |
| ctpv.insert(&*ic0); |
| ++ic0; |
| } |
| |
| /* select the cars in the range given */ |
| |
| car_table_price_view::iterator ictpv0=ctpv.lower_bound(min_price); |
| car_table_price_view::iterator ictpv1=ctpv.upper_bound(max_price); |
| if(ictpv0==ictpv1){ |
| std::cout<<"no cars in the range given"<<std::endl; |
| return 0; |
| } |
| |
| /* list them */ |
| |
| std::cout<<"listing by method 1"<<std::endl; |
| while(ictpv0!=ictpv1){ |
| std::cout<<**ictpv0; |
| ++ictpv0; |
| } |
| std::cout<<std::endl; |
| } |
| |
| { |
| /* method 2 will give the same results */ |
| |
| /* find the cars in the range given */ |
| |
| boost::multi_index::index<car_table,price>::type::iterator ic0,ic1; |
| ic0=get<price>(ct).lower_bound(min_price); |
| ic1=get<price>(ct).upper_bound(max_price); |
| |
| /* construct a view with these */ |
| |
| car_table_manufacturer_view ctmv; |
| while(ic0!=ic1){ |
| ctmv.insert(&*ic0); |
| ++ic0; |
| } |
| |
| /* select the cars with given manufacturer */ |
| |
| car_table_manufacturer_view::iterator ictmv0,ictmv1; |
| boost::tuples::tie(ictmv0,ictmv1)=ctmv.equal_range(cm); |
| if(ictmv0==ictmv1){ |
| std::cout<<"no cars in the range given"<<std::endl; |
| return 0; |
| } |
| |
| /* list them */ |
| |
| std::cout<<"listing by method 2"<<std::endl; |
| while(ictmv0!=ictmv1){ |
| std::cout<<**ictmv0; |
| ++ictmv0; |
| } |
| std::cout<<std::endl; |
| } |
| |
| return 0; |
| } |