Re: Total Newbie Backward Compat Question

In article <J8ydneX3O515aEbanZ2dnUVZ8hednZ2d@[EMAIL PROTECTED]
>,
 Francis Glassborow <francis.glassborow@[EMAIL PROTECTED]
> wrote:

> Daniel T. wrote:
> > Francis Glassborow <francis.glassbo...@[EMAIL PROTECTED]
> wrote:
> > 
> >> This thread begins to smell of dogma.
> > 
> > Agreed, but it is the nature of the environment, we are talking
> > generalities here, not specifics.
> > 
> >> If someone advocated that setters
> >> should always/never return the prior value I would disagree.
> > 
> > Any rule has times when it should be broken, that doesn't mean it
> > shouldn't be a rule.
> > 
> >> IMHO any time that you have a situation where it is very likely that
the
> >> programmer will wish to change state tem****arily and then restore the
> >> old state is one where a getter might legitimately return the prior
state.
> > 
> > And IMHO any time that you have a situation where it is very likely
> > that a client will wish to change the state of an object tem****arily
> > and then restore the old state is one where the object might
> > legitimately provide such functionality. Something like this for
> > example:
> > 
> > class Object {
> > public:
> >    int getValue() const;
> >    int getOldValue() const;
> >    void setValue( int v );
> >       // ensure: getOldValue() == old getValue() &&
> >       //    getValue() == v
> >    void resetValue();
> >       // ensure: getValue() == getOldValue() &&
> >       //    getOldValue() == old getOldValue()
> > };
> > 
> > I guess we can just call this a style difference and agree to
> > disagree.
> 
> However that does not work if we want to stack such state changes for 
> later restoration (at least if I understand your suggestion.

Now you are changing the problem statement on me. :-) In that case it 
would be better to move that into an adaptor. The adaptor can have a 
multi-level stack based system embedded in it if the client needs such 
functionality, and those who don't need it, don't pay for it.

Something like:

class Object {
   int value;
public:
   int getValue() const { return value; }
   void setValue( int v ) { value = v; }
};

class ObjectWithUndo
{
   stack< Object > o;
public:
   int getValue() const { return o.top().getValue(); }
   void setValue( int v ) {
      o.push( o.top() );
      o.setValue( v );
   }
   void undo() {
      o.pop();
   }
};

Deriving both of the above from an ABC that has both the get and set as 
pure-virtual functions may be useful in some contexts.