SNull.h

Go to the documentation of this file.

#ifndef OPAL_SNull_HH
#define OPAL_SNull_HH
 
// ------------------------------------------------------------------------
// $RCSfile: SNull.h,v $
// ------------------------------------------------------------------------
// $Revision: 1.1.1.1 $
// ------------------------------------------------------------------------
// Copyright: see Copyright.readme
// ------------------------------------------------------------------------
//
// Template class: SNull<T>
//
// ------------------------------------------------------------------------
//
// $Date: 2000/03/27 09:33:42 $
// $Author: Andreas Adelmann $
//
// ------------------------------------------------------------------------
 
#include <cerrno>
#include <iostream>
#include "AbstractObjects/Expressions.h"
#include "Expressions/TFunction0.h"
#include "Utilities/DomainError.h"
#include "Utilities/OverflowError.h"
 
namespace Expressions {
 
    // Class SNull
    // ----------------------------------------------------------------------
    //  This expression evaluates a scalar function withoud operands
    //  (e.g. a random generator) and returns the result.
 
    template <class T>
    class SNull : public Scalar<T> {
    public:
        //  Use an operand-less scalar function.
        explicit SNull(const TFunction0<T>& function);
 
        SNull(const SNull<T>&);
        virtual ~SNull();
 
        virtual Scalar<T>* clone() const;
 
        virtual T evaluate() const;
 
        //  If the function is not a random generator, evaluate it and
        //  store the result as a constant.
        static Scalar<T>* make(const TFunction0<T>& function);
 
        virtual void print(std::ostream& str, int precedence = 99) const;
 
    private:
        // Not implemented.
        SNull();
        void operator=(const SNull&);
 
        // The operation function.
        const TFunction0<T>& fun;
    };
 
    // Implementation
    // ------------------------------------------------------------------------
 
    template <class T>
    inline SNull<T>::SNull(const SNull<T>& rhs) : Scalar<T>(rhs), fun(rhs.fun) {}
 
    template <class T>
    inline SNull<T>::SNull(const TFunction0<T>& function) : fun(function) {}
 
    template <class T>
    inline SNull<T>::~SNull() {}
 
    template <class T>
    inline Scalar<T>* SNull<T>::clone() const {
        return new SNull<T>(*this);
    }
 
    template <class T>
    inline T SNull<T>::evaluate() const {
        errno    = 0;
        T result = (*fun.function)();
 
        // Test for run-time evaluation errors.
        switch (errno) {
            case EDOM:
                throw DomainError("SNull:evaluate()");
 
            case ERANGE:
                // Ignore underflow.
                if (result == T(0)) return result;
                throw OverflowError("SNull:evaluate()");
 
            default:
                return result;
        }
    }
 
    template <class T>
    inline Scalar<T>* SNull<T>::make(const TFunction0<T>& fun) {
        return new SNull<T>(fun);
    }
 
    template <class T>
    inline void SNull<T>::print(std::ostream& stream, int) const {
        stream << fun.name << "()";
    }
 
}  // namespace Expressions
 
#endif  // OPAL_SNull_HH