 Boost :

From: Roland Richter (roland_at_[hidden])
Date: 2003-06-07 09:35:42

Dear Nicolas,

sorry for the late reply. Some other projects try to keep me busy.

First, I'd like to mention that in German-speaking countries, EDV
is a very common acronym for "Elektronische Datenverarbeitung"
("electronic data processing"), hence the library name might be
somewhat confusing.

depending on whether these "event-driven" values
(a) actively update their related values whenever changed, or
(b) are passive and do nothing until their value is fetched.

Let me explain this point using your "sum" example:

concrete_value<int> i(4), j(6);
sum_value<int> sum(i, j); // sum now equal to 10

i = 6; // sum now equal to 12

Yeah, right, sum is 12 now - but who cares? It might be 13 or 14
or 2893457923 - you wouldn't notice the difference only until the
value of sum is actually fetched. Oh wait, somebody did just that
some lines later:

sumsum = 2 * sum;

Only here the value of sum gets visible to the outer world, and only
here there is any need to re-calculate its value - a technique called
"lazy evaluation" (for obvious reasons).

If you intend to follow that path - lazy evaluated values - what
you are really doing is symbolic math: forming expressions out
of operators (+, -, ==) and variables (i, j, sum) which might or
might *not* represent a numeric value.

Most major mathematical software distributions work in just that
way and allow you to do something like this:

sum = i + j; // sum evaluates to i + j, because neither i nor j are
// yet bound to a numerical value

i = 6; // sum evaluates to 6 + j
j = pi; // sum evaluates to 6 + pi, or 9.14159.

For a symbolic math package in C++, I'd point you to http://www.ginac.de

I guess, however, that your main interest lies in variant (a),
"event-driven" (opposed to "lazy evaluated") values, that is, in
implementing some special form of the Subject/Observer pattern,
based on boost::signals.

For reasons I pointed out above, this would just make sense if your
main focus is *not* on updating other values, but on triggering some
action, like this:

void print_me( int i )
{
std::cout << i << std::endl;
}

value<int> i( 6, print_me );
i = 42; // Prints 42 to stdout.

In other words, value<Type> would be some type where construction,
assignment, and maybe destruction would call some signals. This might
include, but is not limited to, updating other values.