Re: Defining a cast on a templated class
alan a 9crit :
On Nov 14, 4:40 pm, Michael DOUBEZ <michael.dou...@free.fr> wrote:
Alf P. Steinbach a 9crit :
* alan:
I'm creating a sort-of "wrapper" class which (partly) acts like a
variable. Something like:
template<class t>
class cell{
t curval;
public:
/*public for debugging only - will be private in final version*/
inline cell<t>& set_value(t v){ curval = v; return *this;}
inline t get_value(){ return curval;}
/*actual public interface*/
/*assign to this value*/
inline cell<t>& operator=(t v){ return set_value(v);}
};
[snip: answered]
Basically the cell<> class would be like a spreadsheet cell - when I
assign a formula into it, its value will be automatically updated if
any of the cells in the formula are updated.
The way I intend to implement it is, I extend +-*/ and ?: so that if
any cells are in any parameters, they will instead return a new cell
which registers itself to the input cells. Something like:
template<class t>
cell<t>& operator+(cell<t> v1, t v2){
sum_cell<t> *sum = new sum_cell<t>(v2);
sum.register_yourself_to(v1); //when v1 is update()d, sum's update()
method is called
return (cell<t>&) *sum;
}
If there is already some existing library that does (in some form) the
above, please inform me. I suspect there already is, somehow I have a
feeling I've seen it before.
Perhaps look at the Open Office source?
It is straightforward to use boost::function0<T>(), boost::ref() and
boost::bind() to compose your elements.
Wow. Thanks. I guess I gotta study the boost libraries.
I just used boost::function because it was convenient. If you want
something more evolved, you should look toward counted body idioms and
composite pattern but the principle is the same as here.
inline T get_value()const{ return value();}
I suppose the above call can be turned into:
inline operator T ()const{ return value();}
Yes.
From a basic analysis (correct me if I'm wrong) it seems that the
value is computed only when referenced (and is recomputed each time
it's referenced). Is this correct?
The value is computed only when deferenced.
There are some issue in the code I gave with consts being copied rather
than referenced. This would be solved with a counted body + composite
implementation that I mentionned.
A quick hack would be to use shared_ptr<function0<T> > instead.
Dang, and I was going to implement some crazy updating code for
this...
Anyway I recently learned that ?: can't be overloaded, so I'll have to
do some other crazy things in order to handle conditionals. If ! can
be overloaded like the above (such that !!(foo) returns either 1 or 0,
regardless if foo is 0, 1, 42, or 1838596) possibly I can simply
create a function like so:
template<class T>
cell<T> num_if(cell<T> c, cell<T> t, cell<T> e){
return !!(c) * t + !(c) * e;
}
I don't understand your funtion. You want to do a lazy selector of cell ?
This the implmentation I gave:
template<typename B,class T>
cell<T>& selector(B& b, cell<T>& if_true, cell<T>& if_false)
{
return b?if_true:if_false;
}
And then
template<typename B,class T>
cell<T> select(B& b, cell<T>& if_true, cell<T>& if_false)
{
//suposing cell has a constructor from function0<T>
return cell<T>(boost::bind(selector<B,T>,
boost::ref(b),
boost::ref(if_true),
boost::ref(if_false)));
}
Of course, you would have to provide the same with different
cv-qualifier or use some Boost MPL.
Excuse me for being annal, but you should definitely reimplement it with
counted body + composition rather than boost::function.
Michael