AAutomatic.h

Go to the documentation of this file.

#ifndef OPAL_AAutomatic_HH
#define OPAL_AAutomatic_HH

// ------------------------------------------------------------------------
// $RCSfile: AAutomatic.h,v $
// ------------------------------------------------------------------------
// $Revision: 1.1.1.1.4.1 $
// ------------------------------------------------------------------------
// Copyright: see Copyright.readme
// ------------------------------------------------------------------------
//
// Template class: AAutomatic<T>
//
// ------------------------------------------------------------------------
//
// $Date: 2004/11/18 22:52:40 $
// $Author: jsberg $
//
// ------------------------------------------------------------------------

#include "Expressions/ADeferred.h"
#include "AbstractObjects/Expressions.h"
#include "AbstractObjects/OpalData.h"


namespace Expressions {

    // Template class AAutomatic
    // ----------------------------------------------------------------------
    //  An automatic expression is marked as unknown and registered in a list
    //  when it is created.  When its value is required, it is evaluated,
    //  marked as known, and the new value is cached.  Whenever a new
    //  definition is read, or an existing one is changed, the expressions
    //  are all marked as unknown. This forces a new evaluation when an
    //  exoression is used the next time.

    template <class T>
    class AAutomatic: public ADeferred<T> {

    public:

        //  From array of expressions.
        explicit AAutomatic(PtrToArray<T> expr);

        //  From array expression.
        explicit AAutomatic(ArrayOfPtrs<T> expr);

        AAutomatic(const AAutomatic &);
        virtual ~AAutomatic();

        virtual AAutomatic<T> *clone() const;

        //  The resulting value is cached.
        virtual std::vector<T> evaluate();

        //  Mark as unknown to force re-evaluation of expression.
        virtual void invalidate();

    private:

        // Not implemented.
        AAutomatic();
        void operator=(const AAutomatic &);

        // Is the expression known ?
        mutable bool is_known;
    };


    // Implementation
    // ----------------------------------------------------------------------

    template <class T>
    AAutomatic<T>::AAutomatic(const AAutomatic<T> &rhs):
        ADeferred<T>(rhs),
        is_known(false) {
        OpalData::getInstance()->registerExpression(this);
    }


    template <class T>
    AAutomatic<T>::AAutomatic(PtrToArray<T> expr):
        ADeferred<T>(expr),
        is_known(false) {
        OpalData::getInstance()->registerExpression(this);
    }


    template <class T>
    AAutomatic<T>::AAutomatic(ArrayOfPtrs<T> expr):
        ADeferred<T>(expr),
        is_known(false) {
        OpalData::getInstance()->registerExpression(this);
    }


    template <class T>
    AAutomatic<T>::~AAutomatic() {
        // Unlink expression from expression list.
        OpalData::getInstance()->unregisterExpression(this);
    }


    template <class T>
    AAutomatic<T> *AAutomatic<T>::clone() const {
        return new AAutomatic<T>(*this);
    }


    template <class T>
    std::vector<T> AAutomatic<T>::evaluate() {
        if(! is_known) {
            ADeferred<T>::evaluate();
            is_known = true;
        }

        return this->value;
    }


    template <class T>
    void AAutomatic<T>::invalidate() {
        is_known = false;
    }

}

#endif // OPAL_AAutomatic_HH