SAutomatic.h

Go to the documentation of this file.

#ifndef OPAL_SAutomatic_HH
#define OPAL_SAutomatic_HH
 
// ------------------------------------------------------------------------
// $RCSfile: SAutomatic.h,v $
// ------------------------------------------------------------------------
// $Revision: 1.1.1.1.4.1 $
// ------------------------------------------------------------------------
// Copyright: see Copyright.readme
// ------------------------------------------------------------------------
//
// Template class: SAutomatic<T>
//
// ------------------------------------------------------------------------
//
// $Date: 2004/11/18 22:52:40 $
// $Author: jsberg $
//
// ------------------------------------------------------------------------
 
#include "Expressions/SDeferred.h"
#include "AbstractObjects/Expressions.h"
#include "AbstractObjects/OpalData.h"
 
 
namespace Expressions {
 
    // Template class SAutomatic
    // ----------------------------------------------------------------------
    //  An automatic expression is marked as unknown and registered in a list
    //  when it is created.  When its value is required, it is evaluated, is
    //  marked as known, and the new value is cached.  Whenever a new
    //  definition is read, or an existing one is changed, all expressions
    //  are again marked as unknown.  This forces a new evaluation when an
    //  expression is used the next time.
 
    template <class T> class SAutomatic: public SDeferred<T> {
 
    public:
 
        //  From scalar expression.
        explicit SAutomatic(PtrToScalar<T> expr);
 
        SAutomatic(const SAutomatic<T> &);
        virtual ~SAutomatic();
 
        virtual SAutomatic<T> *clone() const;
 
        //  The resulting value is cached.
        virtual T evaluate();
 
        //  Mark as unknown to force re-evaluation of expression.
        virtual void invalidate();
 
    private:
 
        // Not implemented.
        SAutomatic();
        void operator=(const SAutomatic<T> &);
 
        // Is the expression known ?
        mutable bool is_known;
    };
 
 
    // Implementation
    // ------------------------------------------------------------------------
 
    template <class T>
    SAutomatic<T>::SAutomatic(const SAutomatic<T> &rhs):
        SDeferred<T>(rhs), is_known(false) {
        OpalData::getInstance()->registerExpression(this);
    }
 
 
    template <class T>
    SAutomatic<T>::SAutomatic(PtrToScalar<T> expr):
        SDeferred<T>(expr), is_known(false) {
        OpalData::getInstance()->registerExpression(this);
    }
 
 
    template <class T>
    SAutomatic<T>::~SAutomatic() {
        // Unlink expression from expression list.
        OpalData::getInstance()->unregisterExpression(this);
    }
 
 
    template <class T>
    SAutomatic<T> *SAutomatic<T>::clone() const {
        return new SAutomatic<T>(*this);
    }
 
 
    template <class T>
    T SAutomatic<T>::evaluate() {
        if(! is_known) {
            SDeferred<T>::evaluate();
            is_known = true;
        }
 
        return this->value;
    }
 
 
    template <class T>
    void SAutomatic<T>::invalidate() {
        is_known = false;
    }
 
}
 
#endif // OPAL_SAutomatic_HH