AttributeHandler.h

Go to the documentation of this file.

#ifndef OPAL_AttributeHandler_HH
#define OPAL_AttributeHandler_HH

// ------------------------------------------------------------------------
// $RCSfile: AttributeHandler.h,v $
// ------------------------------------------------------------------------
// $Revision: 1.1.1.1 $
// ------------------------------------------------------------------------
// Copyright: see Copyright.readme
// ------------------------------------------------------------------------
//
// Class: AttributeHandler
//
// ------------------------------------------------------------------------
//
// $Date: 2000/03/27 09:33:34 $
// $Author: Andreas Adelmann $
//
// ------------------------------------------------------------------------

#include "MemoryManagement/RCObject.h"
#include "AbstractObjects/AttributeBase.h"
#include "MemoryManagement/Pointer.h"
#include <string>
#include <map>
#include <set>

class Attribute;
class Statement;


// Class AttributeHandler
// ------------------------------------------------------------------------
//  An attribute parser defines the data type for an attribute.  It is
//  used to parse the attribute, to read the attribute from the DOOM data
//  base, and to write it to that data base.  It contains the name and
//  help text for the attribute.  Optionally it may also contain a default
//  value for the attribute.
//  [p]
//  When ``is_readonly'' is true, the attribute cannot be redefined by
//  the user.
//  [p]
//  When ``is_deferred'' is true, the attribute must be re-evaluated
//  whenever it is used.  This is the case for random error values.
//  When ``is_deferred'' is false, any expression for the attribute is
//  cached.  It is re-evaluated only when any other definition has changed.

class AttributeHandler: public RCObject {

public:

    //  Assigns the attribute name [b]name[/b] and the help text [b]help[/b],
    //  as well as a possible default value [b]def[/b]for the attribute.
    AttributeHandler(const std::string &name, const std::string &help, AttributeBase *def);

    virtual ~AttributeHandler();

    //  Attribute handlers are always shared, so this method should never
    //  be called.  It exists only to fulfill the requirements of the class
    //  [b]Pointer[/b].
    virtual AttributeHandler *clone() const;

    //  Return the default value stored in this parser.
    virtual AttributeBase *getDefault() const;

    virtual const std::string &getHelp() const;

    virtual const std::string &getName() const;

    //  Return a string describing the attribute type
    //  ("logical", "real", etc.).
    virtual const std::string &getType() const = 0;

    //  Parse value from the statement [b]s[/b] and assign it to the
    //  attribute [b]a[/b].
    virtual void parse(Attribute &a, Statement &s, bool eval) const = 0;

    //  Parse value from the statement [b]s[/b] and assign it to the
    //  attribute [b]a[/b], indexed by [b]i[/b].
    //  The default version assumes that the value is scalar,
    //  and it throws [b]OpalException[/b].
    virtual void parseComponent
    (Attribute &a, Statement &s, bool eval, int i) const;

    //  True, if any expression evaluation is to be deferred.
    //  See [b]Expressions::ADeferred[/b] and [b]Expressions::SDeferred[/b]
    //  for details.
    bool isDeferred() const;

    //  If the flag is set, expressions are evaluated only when the value
    //  is fetched.
    void setDeferred(bool);

    //  If [b]parse[/b] is called with this flag set,
    //  then [b]OpalException[/b] is thrown.
    bool isReadOnly() const;

    //  If [b]parse[/b] is called with the flag set,
    //  then [b]OpalException[/b] is thrown.
    void setReadOnly(bool);

    void setPredefinedValues(const std::set<std::string>&, const std::string&);

    enum OwnerType {
        ELEMENT,
        COMMAND,
        SUB_COMMAND,
        STATEMENT,
        NONE};

    static std::multimap<OwnerType, std::string> getOwner(const std::string &att);
    static void addAttributeOwner(const std::string &owner, const OwnerType &type, const std::string &name);
protected:

    const std::string itsName;

    const std::string itsHelp;

    Pointer <AttributeBase> itsDefault;

    bool is_deferred;

    bool is_readonly;

private:

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

    static std::multimap<std::string, std::pair<OwnerType, std::string> > attributeOwnerDictionary_s;
};

#endif // OPAL_AttributeHandler_HH