Boost logo

Boost Users :

Subject: Re: [Boost-users] 'Hashable' concept for type erasure
From: Samuel Christie (schrist_at_[hidden])
Date: 2014-03-24 14:46:02

Interesting. That looks useful, but at the same time I think I can actually
get away without erasing _value. The actual type would be the erased type
we were working on earlier, so I should be able to just stick it in

How would you erase insert() though? Its return type seems fairly
complicated. I tried using std::pair<te::any<te::forward_iterator<> >,
bool>, but I get "invalid initialization of reference of type 'int&' from
expression of type 'const int'" for the simple test case.

Thanks again,


On Sat, Mar 22, 2014 at 8:47 PM, Steven Watanabe <watanabesj_at_[hidden]>wrote:

> On 03/22/2014 05:13 PM, Samuel Christie wrote:
> > Hmm. Maybe it would be best if I make a custom wrapper class anyway,
> then.
> > All I really need is the ability to 1) record 'seen' objects in the
> > history, and 2) be able to tell whether one of the same objects is in the
> > history or not. Up until this point, I've been using unordered_sets, but
> I
> > was hoping to support more sophisticated memory models that would only
> > remember recent history, for instance.
> >
> > Of those choices, I think (b) makes the most sense for my purposes,
> though
> > a or c would also be acceptable. I can't really see how I would achieve
> > that with just type erasure though. This could easily be a case of an
> > over-used hammer.
> >
> Do you actually need to erase the value_type?
> If you can use has_count<size_t(int)>, then
> everything will just work.
> > If you don't mind my asking, which of them would you recommend, which do
> > you think is achievable with type-erasure, and what other alternatives do
> > you think I should be considering?
> >
> If it were just count, I would go for (b). However,
> that isn't an option for insert, since it's impossible
> to insert something that isn't an int into a container
> that stores ints. Whether consistency between the
> functions is more important than the extra convenience,
> only you can decide. Now that I think about it, all these
> options can all be implemented in basically the same way
> (you will need typeid_<_value> for this to work):
> template<class T>
> std::size_t generic_count(const any_set& c, const T& t)
> {
> typedef any<requirements, const _value&> val_ref;
> // check that the type of t matches the value_type
> // of the container.
> if(typeid_of<_value>(binding_of(c)) == typeid(t)) {
> // capture the value in a way that's compatible
> // with the container.
> val_ref v(t, binding_of(c));
> return c.count(v);
> } else {
> return 0; // or throw or whatever
> }
> }
> You can put this directly in the concept_interface,
> if you define it manually instead of using
> In Christ,
> Steven Watanabe
> _______________________________________________
> Boost-users mailing list
> Boost-users_at_[hidden]

Boost-users list run by williamkempf at, kalb at, bjorn.karlsson at, gregod at, wekempf at