LELInterface.h

Classes

LELInterface -- This base class provides the interface for Lattice expressions (full description)

template <class T> class LELInterface

Interface

Public Members
virtual ~LELInterface()
virtual void eval (LELArray<T>& result, const Slicer& section) const = 0
virtual void evalRef (LELArrayRef<T>& result, const Slicer& section) const
virtual LELScalar<T> getScalar() const = 0
LELArray<T> getArray() const
virtual Bool prepareScalarExpr() = 0
Bool isScalar() const
const IPosition& shape() const
const LELAttribute& getAttribute() const
virtual String className() const = 0
static Bool replaceScalarExpr (CountedPtr<LELInterface<T> >& expr)
virtual Bool lock (FileLocker::LockType, uInt nattempts)
virtual void unlock()
virtual Bool hasLock (FileLocker::LockType) const
virtual void resync()
Protected Members
void setAttr(const LELAttribute& attrib)

Description

Review Status

Date Reviewed:
yyyy/mm/dd

Prerequisite

Etymology

The name means "Lattice Expression Language Interface". This class provides the declaration for the interface for classes that are to provide Lattice expression computational functionality

Synopsis

This class is part of the Letter/envelope scheme which enables the C++ programmer to write mathematical expressions involving Lattices. The envelope class LatticeExpr invokes the bridge class LatticeExprNode. LatticeExprNode activates the letter classes which provide the real functionality.

A description of the implementation details of these classes can be found in Note 216

This class, LELInterface, is the abstract base class for all of the letter classes. Its purpose is to declare the interface inherited by all of its derived classes which are used polymorphically. The derived classes offer the functionality to create and evaluate the expression tree that results from the compiler parsing the expression. For example, these derived classes are activated by LatticeExprNode to handle operations like reading pixels from a Lattice, applying binary operations to Lattices, applying mathematical functions to Lattices and so on.

The heart of the interface is in the functions eval and getScalar. These recursively evaluate the result of the current expression when the result is either an array or a scalar, respectively. The need for recursion can be understood with a simple example.

Consider an expression summing two Lattices such as "2*(b+c)". The expression tree consists of nodes (leaves) that 1) get Lattice pixels from the Lattice (expressions "b" and "c"), 2) add the pixel values of the Lattices together (operator "+"), and 3) multiply a Lattice by a scalar (operator "*"). At the top of the tree, we have a scalar (2.0) and a Lattice (the result of "b+c"). The top-of-the-tree expression has to multiply them together. That's what the eval function for the "*" operation needs to do. The key is that each of the "2.0" and "b+c" are really Lattice expressions themselves and they can be evaluated. So before the "*" eval function can multiply its two expressions together, it must individually evaluate them. Thus, it first calls the getScalar function of the object housing the expression "2.0". This will in fact return the scalar value "2.0". Then it calls eval on the expression object housing "b+c". This object in turn first calls eval on the left ("b") and right ("c") expressions which results in the pixels for the Lattices being returned. It then adds them together, returning the result to the top of the tree where they are multiplied by 2. You can see that since all these different expression objects call the eval or getScalar function that they all inherit from LELInterface. Indeed for our example above, the actual classes involved are are LELLattice (get pixels from Lattice) and LELBinary ("+" and "*" operators) which inherit from LELInterface. When these objects are constructed, they work out whether the result of their evaluation is a scalar or not. This is how the classes higher up the tree know whether to call eval or getScalar.

The results of the computations are either returned in the buffer in the eval function or by value by getScalar

The classes evaluate the expression for each specified Lattice chunk (usually tile by tile). The section argument in the eval function specifies the section of the Lattice being evaluated. The absence of the section argument in the getScalar function emphasises the scalar nature; a scalar expression does not have a shape. For most of the letter classes, the section argument is irrelevant; the only one it really matters for is LELLattice which fetches the pixels from the Lattice. The rest only care about the shape of the buffer in the eval call.

Motivation

The many letter classes that actually do the computational work are used polymorphically. Therefore, they must have a base class declaring the interface.

To Do

Member Description

virtual ~LELInterface()

Virtual destructor

virtual void eval (LELArray<T>& result, const Slicer& section) const = 0

Evaluate the expression and fill the result array

virtual void evalRef (LELArrayRef<T>& result, const Slicer& section) const

virtual LELScalar<T> getScalar() const = 0

Get the result of a scalar subexpression.

LELArray<T> getArray() const

Get the result of an array subexpression. It does eval for the entire array. An exception is thrown if the shape of the subexpression is unknown.

virtual Bool prepareScalarExpr() = 0

Do further preparations (e.g. optimization) on the expression. It returns True if the expression is an invalid scalar (i.e. with a False mask). That can happen if the expression has a component with an invalid scalar value (e.g. min(lattice) where lattice contains no valid elements).

Bool isScalar() const

Is the result of evaluating this expression a scalar ?

const IPosition& shape() const

Get the shape of the expression result.

const LELAttribute& getAttribute() const

Get expression attribute

virtual String className() const = 0

Get class name

static Bool replaceScalarExpr (CountedPtr<LELInterface<T> >& expr)

If the given expression is a valid scalar, replace it by its result. It returns False if the expression is no scalar or if the expression is an invalid scalar (i.e. with a False mask).

virtual Bool lock (FileLocker::LockType, uInt nattempts)
virtual void unlock()
virtual Bool hasLock (FileLocker::LockType) const
virtual void resync()

Handle locking/syncing of the parts of a lattice expression.
By default the functions do not do anything at all. lock() and hasLock return True.

void setAttr(const LELAttribute& attrib)

Set the expression attributes of this object.