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/Invalidator.h"
#include "AbstractObjects/Expressions.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):
    RCObject(), 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):
    RCObject(), 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;
}