Object.cpp

Go to the documentation of this file.

// ------------------------------------------------------------------------
// $RCSfile: Object.cpp,v $
// ------------------------------------------------------------------------
// $Revision: 1.4 $
// ------------------------------------------------------------------------
// Copyright: see Copyright.readme
// ------------------------------------------------------------------------
//
// Class: Object
//   This abstract base class defines the common interface for all
//   objects defined in OPAL.
//
// ------------------------------------------------------------------------
//
// $Date: 2000/12/15 10:04:08 $
// $Author: opal $
//
// ------------------------------------------------------------------------
 
#include "AbstractObjects/Object.h"
#include "AbstractObjects/Attribute.h"
#include "AbstractObjects/Expressions.h"
#include "AbstractObjects/Invalidator.h"
#include "OpalParser/Statement.h"
#include "Utilities/Options.h"
#include "Utilities/ParseError.h"
#include "Utilities/Util.h"
 
#include <cmath>
#include <iostream>
#include <vector>
 
extern Inform* gmsg;
 
// Class Object
// ------------------------------------------------------------------------
 
Object::~Object() {
    // Invalidate all references to this object.
    for (std::set<Invalidator*>::iterator i = references.begin(); i != references.end(); ++i) {
        (*i)->invalidate();
    }
}
 
bool Object::canReplaceBy(Object*) {
    // Default action: no replacement allowed.
    return false;
}
 
void Object::copyAttributes(const Object& source) { itsAttr = source.itsAttr; }
 
void Object::execute() {
    // Default action: do nothing.
}
 
Attribute* Object::findAttribute(const std::string& name) {
    for (std::vector<Attribute>::iterator i = itsAttr.begin(); i != itsAttr.end(); ++i) {
        if (i->getName() == name) return &(*i);
    }
    return nullptr;
}
 
const Attribute* Object::findAttribute(const std::string& name) const {
    for (std::vector<Attribute>::const_iterator i = itsAttr.begin(); i != itsAttr.end(); ++i) {
        if (i->getName() == name) return &(*i);
    }
 
    return 0;
}
 
Object* Object::makeTemplate(const std::string& name, TokenStream&, Statement&) {
    throw ParseError(
            "Object::makeTemplate()", "Object \"" + name + "\" cannot be used to define a macro.");
}
 
Object* Object::makeInstance(const std::string& /*name*/, Statement&, const Parser*) {
    throw ParseError(
            "Object::makeInstance()",
            "Object \"" + getOpalName() + "\" cannot be called as a macro.");
}
 
void Object::parse(Statement& stat) {
    while (stat.delimiter(',')) {
        std::string name = Expressions::parseString(stat, "Attribute name expected.");
 
        if (Attribute* attr = findAttribute(name)) {
            if (stat.delimiter('[')) {
                int index = int(std::round(Expressions::parseRealConst(stat)));
                Expressions::parseDelimiter(stat, ']');
 
                if (stat.delimiter('=')) {
                    attr->parseComponent(stat, true, index);
                } else if (stat.delimiter(":=")) {
                    attr->parseComponent(stat, false, index);
                } else {
                    throw ParseError("Object::parse()", "Delimiter \"=\" or \":=\" expected.");
                }
            } else if (stat.delimiter('=')) {
                attr->parse(stat, true);
            } else if (stat.delimiter(":=")) {
                attr->parse(stat, false);
            } else {
                attr->setDefault();
            }
        } else {
            throw ParseError(
                    "Object::parse()",
                    "Object \"" + getOpalName() + "\" has no attribute \"" + name + "\".");
        }
    }
}
 
void Object::parseShortcut(Statement& stat, bool eval) {
    // Only one attribute.
    if (stat.delimiter(',')) {
        stat.mark();
        std::string name;
 
        if (stat.word(name)) {
            if (stat.delimiter('=')) {
                if (Attribute* attr = findAttribute(name)) {
                    attr->parse(stat, eval);
                    return;
                } else {
                    throw ParseError(
                            "Object::parseShortcut()",
                            "Object \"" + getOpalName() + "\" has no attribute \"" + name + "\".");
                }
            } else if (stat.delimiter(":=")) {
                if (Attribute* attr = findAttribute(name)) {
                    attr->parse(stat, false);
                    return;
                } else {
                    throw ParseError(
                            "Object::parseShortcut()",
                            "Object \"" + getOpalName() + "\" has no attribute \"" + name + "\".");
                }
            }
        }
 
        stat.restore();
        itsAttr[0].parse(stat, false);
    }
}
 
void Object::print(std::ostream& msg) const {
    std::string head = getOpalName();
    Object* parent   = getParent();
    if (parent != 0 && !parent->getOpalName().empty()) {
        if (!getOpalName().empty()) head += ':';
        head += parent->getOpalName();
    }
 
    msg << head;
    int pos = head.length();
 
    for (std::vector<Attribute>::const_iterator i = itsAttr.begin(); i != itsAttr.end(); ++i) {
        if (*i) i->print(pos);
    }
    msg << ';';
    msg << std::endl;
    return;
}
 
void Object::registerReference(Invalidator* ref) { references.insert(ref); }
 
void Object::unregisterReference(Invalidator* ref) { references.erase(ref); }
 
void Object::registerOwnership(const AttributeHandler::OwnerType& itsClass) const {
    if (getParent() != 0) return;
 
    const unsigned int end = itsAttr.size();
    const std::string name = getOpalName();
    for (unsigned int i = 0; i < end; ++i) {
        AttributeHandler::addAttributeOwner(name, itsClass, itsAttr[i].getName());
    }
}
 
void Object::printHelp(std::ostream& /*os*/) const {
    *gmsg << endl << itsHelp << endl;
 
    if (!itsAttr.empty()) {
        *gmsg << "Attributes:" << endl;
 
        size_t maxNameLength = 16;
        size_t maxTypeLength = 16;
        std::vector<Attribute>::const_iterator it;
        for (it = itsAttr.begin(); it != itsAttr.end(); ++it) {
            std::string name = it->getName();
            maxNameLength    = std::max(maxNameLength, name.length() + 1);
            std::string type = it->getType();
            maxTypeLength    = std::max(maxTypeLength, type.length() + 1);
        }
 
        for (it = itsAttr.begin(); it != itsAttr.end(); ++it) {
            std::string type = it->getType();
            std::string name = it->getName();
            std::istringstream help(it->getHelp());
            std::vector<std::string> words;
            std::copy(
                    std::istream_iterator<std::string>(help), std::istream_iterator<std::string>(),
                    std::back_inserter(words));
            unsigned int columnWidth = 40;
            if (maxNameLength + maxTypeLength < 40u) {
                columnWidth = 80 - maxNameLength - maxTypeLength;
            }
 
            auto wordsIt  = words.begin();
            auto wordsEnd = words.end();
            while (wordsIt != wordsEnd) {
                *gmsg << '\t' << type << std::string(maxTypeLength - type.length(), ' ');
                *gmsg << name << std::string(maxNameLength - name.length(), ' ');
                unsigned int totalLength = 0;
                do {
                    totalLength += wordsIt->length();
                    *gmsg << *wordsIt << " ";
                    ++wordsIt;
                } while (wordsIt != wordsEnd && totalLength + wordsIt->length() < columnWidth);
                if (wordsIt != wordsEnd) {
                    *gmsg << endl;
                }
 
                type = "";
                name = "";
            }
 
            if (it->isReadOnly()) *gmsg << " (read only)";
            *gmsg << endl;
        }
    }
 
    *gmsg << endl;
}
 
void Object::replace(Object*, Object*) {
    // Default action: do nothing.
}
 
void Object::update() {
    // Default action: do nothing.
}
 
bool Object::isBuiltin() const { return builtin; }
 
bool Object::isShared() const { return sharedFlag; }
 
void Object::setShared(bool flag) { sharedFlag = flag; }
 
void Object::setDirty(bool dirty) {
    // The object is now different from the data base.
    modified = dirty;
}
 
bool Object::isDirty() const { return modified; }
 
void Object::setFlag(bool flag) { flagged = flag; }
 
bool Object::isFlagged() const { return flagged; }
 
const Object* Object::getBaseObject() const {
    const Object* base = this;
    while (base->itsParent != 0)
        base = base->itsParent;
    return base;
}
 
const std::string& Object::getOpalName() const { return itsName; }
 
Object* Object::getParent() const { return itsParent; }
 
bool Object::isTreeMember(const Object* classObject) const {
    const Object* object = this;
 
    while (object != 0 && object != classObject) {
        object = object->itsParent;
    }
 
    return object != 0;
}
 
void Object::setOpalName(const std::string& name) { itsName = name; }
 
void Object::setParent(Object* parent) { itsParent = parent; }
 
void Object::clear() { occurrence = 0; }
 
int Object::increment() { return ++occurrence; }
 
int Object::occurrenceCount() { return occurrence; }
 
Object::Object(int size, const char* name, const char* help)
    : itsAttr(size), itsParent(0), itsName(name), itsHelp(help), occurrence(0), sharedFlag(false) {
    // NOTE: The derived classes must define the attribute handlers and
    //       any initial values for the attributes.
 
    // The object is an exemplar and must not be saved in the data base.
    builtin = true;
    flagged = modified = false;
}
 
Object::Object(const std::string& name, Object* parent)
    : itsAttr(parent->itsAttr),
      itsParent(parent),
      itsName(name),
      itsHelp(parent->itsHelp),
      occurrence(0),
      sharedFlag(false) {
    // The object is now different from the data base.
    builtin = flagged = false;
    modified          = true;
}
 
std::ostream& operator<<(std::ostream& os, const Object& object) {
    object.print(os);
    return os;
}