Table.h

Go to the documentation of this file.

#ifndef OPAL_Table_HH
#define OPAL_Table_HH 1
 
// ------------------------------------------------------------------------
// $RCSfile: Table.h,v $
// ------------------------------------------------------------------------
// $Revision: 1.1.1.1 $
// ------------------------------------------------------------------------
// Copyright: see Copyright.readme
// ------------------------------------------------------------------------
//
// Class: Table
//
// ------------------------------------------------------------------------
//
// $Date: 2000/03/27 09:33:35 $
// $Author: Andreas Adelmann $
//
// ------------------------------------------------------------------------
 
#include <vector>
#include "AbstractObjects/Expressions.h"
#include "AbstractObjects/Object.h"
 
class Attribute;
class Beamline;
class PlaceRep;
class RangeRep;
 
// Class Table
// ------------------------------------------------------------------------
//  It implements the common behaviour of tables, it can also be used via
//  dynamic casting to determine whether an object represents a table.
//  During matching operations, a Table must often be recalculated.  This
//  is done by calling its [tt]fill()[/tt] method.  To avoid unnecessary
//  filling, the user may define a table as ``static'' in the command
//  creating the table.  In this case OPAL assumes that the table never
//  changes.
 
class Table : public Object {
public:
    struct Cell {
        Cell(Expressions::PtrToScalar<double> expr, int width, int prec)
            : itsExpr(expr), printWidth(width), printPrecision(prec) {}
 
        Expressions::PtrToScalar<double> itsExpr;
 
        int printWidth;
 
        int printPrecision;
    };
 
    typedef std::vector<Cell> CellArray;
 
    virtual ~Table();
 
    //  A table cannot be replaced, thus this method never returns true.
    virtual bool canReplaceBy(Object* newObject);
 
    //  If [b]refill[/b] is true, call the table algorithm to fill the buffer.
    virtual void fill() = 0;
 
    //  If a table with name [b]name[/b] exists, return a pointer to that table.
    //  If no such table exists, throw OpalException.
    static Table* find(const std::string& name);
 
    //  Return the string "TABLE".
    virtual const std::string getCategory() const;
 
    //  If true, the object's execute() function should be traced.
    //  Always true for tables.
    virtual bool shouldTrace() const;
 
    //  If true, the data structure should be updated before calling execute().
    //  Always true for tables.
    virtual bool shouldUpdate() const;
 
    //  Return the value stored in the table cell identified by the row
    //  at [b]row[/b] and the column name [b]col[/b].
    virtual double getCell(const PlaceRep& row, const std::string& col) = 0;
 
    virtual std::vector<double> getColumn(const RangeRep& range, const std::string& col) = 0;
 
    //  Returns an array of column descriptors, which, when applied to a
    //  row of the table, gives the default print columns for this table.
    virtual CellArray getDefault() const = 0;
 
    //  Returns the geometric length of the underlying beam line.
    virtual double getLength() = 0;
 
    //  Returns the OPALX beamline representing the table.
    //  The data of the table are attached to each position in the line.
    virtual const Beamline* getLine() const = 0;
 
    //  Returns the values stored in the row specified by the first argument,
    //  with columns selected by the names stored in the second argument.
    virtual std::vector<double> getRow(const PlaceRep&, const std::vector<std::string>&) = 0;
 
    virtual void invalidate();
 
    //  Must be overridden in derived classes.
    virtual bool isDependent(const std::string& name) const = 0;
 
    virtual Expressions::PtrToScalar<double> makeColumnExpression(const std::string&) const = 0;
 
    virtual bool matches(Table* rhs) const = 0;
 
    virtual void printTable(std::ostream&, const CellArray&) const = 0;
 
protected:
    Table(int size, const char* name, const char* help);
 
    Table(const std::string& name, Table* parent);
 
    //  If true, the table is dynamic.  If it is also invalidated,
    //  it will be refilled when fill() is called.
    bool dynamic;
 
    //  If true, the table has been invalidated.  If it is also dynammic,
    //  it will be refilled when fill() is called.
    bool refill;
 
private:
    // Not implemented.
    Table();
    Table(const Table&);
    void operator=(const Table&);
};
 
#endif  // OPAL_Table_HH