C++: Determine the class of a pointer type in the use of Boost MultiIndex

Question

The answer to this question has general application, but I will motivate it with the following example:

I have the following template class:

template <typename V>
class Collection
{
public:
    struct id{};
    struct name{};
    // A collection parameterized by type V that is indexed by a string 'name'
    // and a integer 'id'
    // The type V must implement 'get_id()' and a 'get_name()' functions
    typedef multi_index_container <
        V,
        indexed_by<
            ordered_unique<
                tag<id>, const_mem_fun<V, unsigned int, &V::get_id> >,
            ordered_unique<
                tag<name>, const_mem_fun<V, std::string, &V::get_name> >
        >
    > ni_collection;
>

I want to modify this template so that I can create a collection with the objects, their pointers or their references: Collection<Obj>, Collection<std::unique_ptr<Obj>> or Collection<Obj *>.

How would I modify my template to achieve this?

--- UPDATE --- I had posted a related question here: Computing The Type Of A Function Pointer

Synthesizing the excellent answers in both places, I have finally achieved my original goal. Here are the details of my current implementation:

template <typename V>
class Collection
{
private:
// A type-level function that returns the undecorated type of the object
// So unrwap_object_type<Widget *> = Widget
//    unwrap_object_type<std::unique_ptr<Widget>> = Widget
//    unwrap_object_type<Widget> = Widget
template<typename T, typename = void>
struct unwrap_object_type { typedef T type; };

template <typename T>
struct unwrap_object_type<T *, void> { typedef T type; };

template<typename T>
struct unwrap_object_type<T,
    typename std::conditional<false,
        typename T::element_type, void>::type>
{
  typedef typename T::element_type type;
};
////

// So that QHNETO_COLLECTION<Widget>, QHNETO_COLLECTION<Widet *>,
// and QHNETO_COLLECTION<std::unique_ptr<Widget>> are valid
typedef typename unwrap_object_type<V>::type W;

// Tags for the two indices (id and name) of the collection
struct id;
struct name;

// A collection parameterized by type V that is indexed by a string 'name'
// and a integer 'id'
// The type V must implement 'get_id()' and a 'get_name()' functions
typedef multi_index_container <
    V,
    indexed_by<
        ordered_unique<
            tag<id>,
            const_mem_fun<W, unsigned int, &W::get_id> >,
        ordered_unique<
            tag<name>,
            const_mem_fun<W, std::string, &W::get_name> >
    >
> ni_collection;

ni_collection m_collection;
};

To clarify -- you want to instantiate it with `const Obj &`, and get the same type as `Collection`, or truly get a container of references? Note that making containers with `const` or `&` types doesn't always work, for instance, std::vector needs to be able to reuse the space when it is resized, afair in C++98 it wasn't possible to instantiate a `std::vector` of references. http://stackoverflow.com/questions/922360/why-cant-i-make-a-vector-of-references — Chris Beck, Jan 09 '16 at 02:18
@ChrisBeck Lets leave out the Collection for this discussion. I want to be able to define a template class Collection that would work with a T and a T*. Here is another example that may help: http://www.boost.org/doc/libs/1_60_0/libs/multi_index/doc/tutorial/key_extraction.html#const_mem_fun — unshul, Jan 09 '16 at 08:14

score 2 · Answer 1 · answered Jan 09 '16 at 13:16

You can use a custom key extractor. E.g: Advanced features of Boost.MultiIndex key extractors

For reference elements, consider boost::reference_wrapper or std::reference_wrapper

Live On Coliru

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

namespace bmi = boost::multi_index;

template <typename V> class Collection {
    struct id_extractor {
        typedef unsigned result_type;
        template <typename U> result_type operator()(U const&e) const { return e.get_id(); }
        template <typename U> result_type operator()(U*e)       const { return e->get_id(); }
    };
    struct name_extractor {
        typedef std::string result_type;
        template <typename U> result_type const& operator()(U const&e) const { return e.get_name(); }
        template <typename U> result_type const& operator()(U*e)       const { return e->get_name(); }
    };
  public:
    struct id;
    struct name;

    // A collection parameterized by type V that is indexed by a string 'name'
    // and a integer 'id'
    // The type V must implement 'get_id()' and a 'get_name()' functions
    typedef boost::multi_index_container<
        V, bmi::indexed_by<bmi::ordered_unique<bmi::tag<id>, name_extractor >,
                           bmi::ordered_unique<bmi::tag<name>, id_extractor > > >
        ni_collection;
};

struct Demo {
    unsigned _id;
    std::string _name;

    unsigned           get_id() const { return _id; }
    std::string const& get_name() const { return _name; }
};

int main() {
    Collection<Demo>::ni_collection works{ { 42, "LTUAE" }, { 4, "PI" } };
    Collection<Demo *>::ni_collection also_works{ new Demo{ 42, "LTUAE" }, new Demo{ 4, "PI" } };
}

thanks! I will try this out. Will this work with shared pointers? — unshul, Jan 09 '16 at 18:00

Joaquín M López Muñoz · Accepted Answer · 2016-01-10T00:39:32.487

Elaborating on @sehe's answer: Boost.MultiIndex predefined key extractors handle dereferencing automatically (for instance, const_mem_fun<foo,bar,&foo::bar> can be used as is with a multi_index_container of foo*s). You can take advantage of this capability and write the following (without any user-provided key extractor):

Live On Coliru

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

namespace bmi = boost::multi_index;

template<typename T>
struct remove_pointer{using type=T;};

template<typename T>
struct remove_pointer<T*>{using type=T;};

template<typename T>
struct remove_pointer<std::shared_ptr<T>>{using type=T;};

template <typename V> class Collection {
  public:
    struct id;
    struct name;

    using W=typename remove_pointer<V>::type;

    typedef boost::multi_index_container<
        V,
        bmi::indexed_by<
            bmi::ordered_unique<
                bmi::tag<id>,
                bmi::const_mem_fun<W, unsigned int, &W::get_id>
            >,
            bmi::ordered_unique<
                bmi::tag<name>,
                bmi::const_mem_fun<W,const std::string&, &W::get_name> 
            > 
        >
    > ni_collection;
};

struct Demo {
    unsigned _id;
    std::string _name;

    Demo(unsigned _id,const std::string& _name):_id(_id),_name(_name){}

    unsigned           get_id() const { return _id; }
    std::string const& get_name() const { return _name; }
};

int main() {
    Collection<Demo>::ni_collection works{ { 42, "LTUAE" }, { 4, "PI" } };
    Collection<Demo *>::ni_collection also_works{ new Demo{ 42, "LTUAE" }, new Demo{ 4, "PI" } };
    Collection<std::shared_ptr<Demo>>::ni_collection this_too{ std::make_shared<Demo>( 42, "LTUAE" ), std::make_shared<Demo>( 4, "PI" ) };
}

The only tricky part is that const_mem_fun uses W=std::remove_pointer<V>::type (i.e. V if V is a plain type or the type it points to if it's a pointer).

Edited: Instead of std::remove_pointer<V>, the updated code uses a handcrafted remove_pointer template class partially specialized to understand T* and std::shared_ptr<T>; you can extend this to cover, for instance, std::unique_ptr<T> or any other smart pointer class you need to cater to.

I was on my to get there. Perhaps this could be mentioned right in the documentation I linked. Because that sends people down the wrong road, IMHO :) — sehe, Jan 09 '16 at 20:32
It is in fact mentioned in the doc you linked: see the paragraph starting with "This possibility is fully exploited by predefined key extractors provided by Boost.MultiIndex[...]" and the example with `employee *`s right after that. — Joaquín M López Muñoz, Jan 09 '16 at 20:36
Mmm. That's not hard to miss. Perhaps the accent should be on the recommended way, instead of the tedious way? I knew about this feature before so I specifically searched for it (and was disappointed to find the tedious way... I admit I didn't read far enough, but you know what it means when people stumble - even when they knew). [I can /see/ the value in demonstrating the manual way too, to be complete] — sehe, Jan 09 '16 at 20:39
You're right. I'm very lazy when it comes to updating docs, but I should change that section so that predefined capabiities come first, as this is expected to be used much more than the user-provided option. Adding to my todo list :-) — Joaquín M López Muñoz, Jan 09 '16 at 20:45
To be honest, I didn't expect I was going to be maintaining the lib 12 years after I first wrote it... — Joaquín M López Muñoz, Jan 09 '16 at 20:48
@sehe and @Joaquín M López Muñoz : Thanks! This is really where I wanted to get to. Now, how do I modify `using W=typename std::remove_pointer::type;` to get it to work with smart pointers. I am willing to sacrifice raw pointers if I have to. Thanks again. — unshul, Jan 09 '16 at 22:08

C++: Determine the class of a pointer type in the use of Boost MultiIndex

2 Answers2

Linked