How to signal expensive vs cheap template parameters? - c++

Question

I have working code for a simple bi_map, a bi-directional map class for storing associated key-value pairs in both directions. My current usage is, NID is some kind of numerical-id or enumeration, while OBJ is an expensive non-copyable class object.
Recently, I've noticed that I also have need for bi_map<NID,std::string>, std::string is a cheap OBJ that should really just be copied.
What is the right way to generalize the code below so that user can signal whether something is expensive (I want to use pointers/references) or cheap (I want to copy everything by value), so that I can use the proper implementation?
CODE
template<typename NID,typename OBJ>
class bi_map
{
std::map<NID,OBJ*> m_nid_2_ptr;
std::map<OBJ const*,NID> m_ptr_2_nid;
public:
void insert( NID nid, OBJ& obj )
{
m_nid_2_ptr.insert( std::make_pair( nid, &obj ));
m_ptr_2_nid.insert( std::make_pair( &obj, nid ));
}
NID operator[]( OBJ const& obj ) const
{
return m_ptr_2_nid.at( &obj );
}
OBJ const& operator[]( NID nid ) const
{
return *(m_nid_2_ptr.at( nid ));
}
using pairs_cb = std::function<void(NID,OBJ const&)>;
void pairs( pairs_cb cb ) const
{
for( const auto& p : m_nid_2_ptr )
cb( p.first, *p.second );
}
size_t size() const { return m_nid_2_ptr.size(); }
};

Answer 1

In general, there are multiple options and I guess, there is no one right answer. So, let's try to find something which works for you. You said you'd like to distinguish between cheap and expensive types. The most important design choice is the interface. You could use:
1) Specialize the template for pointers, having the explicit clue in the inteface that you are using a cheap type:
bi_map< int, std::string* > bi_map_1; // note * is to flag std::string as cheap
bi_map< int, ExpensiveObject > bi_map_2; // no *, thus using heavy implementation
which is implemented like this:
template< typename NID, typename OBJ >
struct bi_map
{
// implementation for expensive objects, use OBJ* or std::shared_ptr<OBJ>
};
// specialize of the second parameter is a pointer
template< typename NID, typename OBJ >
struct bi_map< NID, OBJ* >
{
// implementation for cheap objects, store a copy, i.e., use OBJ
};
of course you could also use & instead of * to flag the types if you find that more readable.
2) If you don't want the cheap/expensive separation to show up in the interface, i.e., if you want
bi_map< int, std::string > bi_map_1; // no *
bi_map< int, ExpensiveObject > bi_map_2; // no *
you need something different. One solution would be adding a defaulted template parameter:
template< typename >
struct is_expensive_for_bi_map : std::false_type {};
template< typename IND, typename OBJ, bool = is_expensive_for_bi_map< OBJ >::value >
struct bi_map
{
// implementation for expensive objects, use OBJ* or std::shared_ptr<OBJ>
};
template< typename NID, typename OBJ >
struct bi_map< NID, OBJ, false >
{
// implementation for cheap objects, store a copy, i.e., use OBJ
};
and for each type that you consider expensive, you add
template<>
struct is_expensive_for_bi_map< ExpensiveObject > : std::true_type {};
If expensive should be the default, just reverse the names and adapt the rest, should be easy enough.

Answer 2

Another option:
template<typename T>
struct notExpensive {
static const bool value = FALSE;
typedef T REF;
static T& ref(T& x) { return x; }
static T& deref(T& x) { return x; }
};
template<typename T>
struct isExpensive {
static const bool value = TRUE;
typedef T* REF;
static T* ref(T& x) { return &x; }
static T deref(T* x) { return x; }
};
template<typename T>
struct expensiveP : public notExpensive<T> {};
// List of expensive types:
template<> struct expensiveP<ExpensiveObject> : public isExpensive<T> {};
Then fill BiMap with expensiveP calls.