ExtrapolatorBase<Value, TimeType>& updateValue(const TimeType&t, const Value&l) {
     mValuePast=TemporalValueType(t,extrapolate(t));
     mValuePresent.updateValue(t,l);
     return *this;
 }

 template <class Functor> bool templatedPropertyHolds(const TimeType&t, const Functor &f)const{
     DurationType timeSinceUpdate=t-lastUpdateTime();
     if (timeSinceUpdate<mFadeTime) {
         return f(mValuePast.value())&&f(mValuePresent.value());
     }else {
         return f(mValuePresent.value());
     }
 }

 Value extrapolate(const TimeType&t) const {
     DurationType timeSinceUpdate=t-lastUpdateTime();
     if (mFadeTime<timeSinceUpdate) {
         return mValuePresent.extrapolate(t);
     }else{
         return mValuePast.extrapolate(t)
             .blend(mValuePresent.extrapolate(t),
                    timeSinceUpdate/mFadeTime);
     }
 }

 Value extrapolate(const TimeType&t) const
 {
     DurationType timeSinceUpdate = std::max(DurationType::zero(),t-lastUpdateTime());
     if (mFadeTime<=timeSinceUpdate) {
         return mValuePresent.extrapolate(t);
     }else{
         return mValuePast.extrapolate(t)
             .blend(mValuePresent.extrapolate(t),
                    (float32)(timeSinceUpdate/mFadeTime));
     }
 }

    ExtrapolatorBase<Value, TimeType>& resetValue(const TimeType&t, const Value&l) {
	mValuePresent.updateValue(t,l);
	mValuePast = mValuePresent;
	return *this;
    }

 TimeType lastUpdateTime()const{
     return mValuePresent.time();
 }

 const Value& lastValue() const {
     return mValuePresent.value();
 }