Attribute.cpp

Go to the documentation of this file.

// ------------------------------------------------------------------------
// $RCSfile: Attribute.cpp,v $
// ------------------------------------------------------------------------
// $Revision: 1.3.4.1 $
// ------------------------------------------------------------------------
// Copyright: see Copyright.readme
// ------------------------------------------------------------------------
//
// Class Attribute:
//   Interface a polymorphic attribute, including its parser.
//
// ------------------------------------------------------------------------
//
// $Date: 2002/12/09 15:06:07 $
// $Author: jsberg $
//
// ------------------------------------------------------------------------
 
#include "AbstractObjects/Attribute.h"
#include "AbstractObjects/AttributeBase.h"
#include "Utilities/Options.h"
 
#include "Utility/Inform.h"
 
#include <set>
#include <iostream>
 
extern Inform *gmsg;
 
 
// Class Attribute
// ------------------------------------------------------------------------
 
Attribute::Attribute():
    base(nullptr),
    handler(),
    isDefault(true)
{}
 
 
Attribute::Attribute(const Attribute &rhs):
    base(rhs.base),
    handler(rhs.handler),
    isDefault(rhs.isDefault)
{}
 
 
Attribute::Attribute(AttributeHandler *h, AttributeBase *b):
    base(b),
    handler(h),
    isDefault(true)
{}
 
 
Attribute::~Attribute()
{}
 
 
const Attribute &Attribute::operator=(const Attribute &rhs) {
    if(&rhs != this) {
        base = std::shared_ptr<AttributeBase>(rhs.base);
        handler = std::shared_ptr<AttributeHandler>(rhs.handler);
    }
 
    return *this;
}
 
 
AttributeBase &Attribute::getBase() const {
    return *base;
}
 
bool Attribute::isBaseAllocated() const {
    return base != nullptr;
}
 
AttributeHandler &Attribute::getHandler() const {
    return *handler;
}
 
 
const std::string &Attribute::getHelp() const {
    return handler->getHelp();
}
 
 
std::string Attribute::getImage() const {
    return base->getImage();
}
 
 
const std::string &Attribute::getName() const {
    return handler->getName();
}
 
 
const std::string &Attribute::getType() const {
    return handler->getType();
}
 
 
bool Attribute::isDeferred() const {
    return handler->isDeferred();
}
 
 
void Attribute::setDeferred(bool flag) {
    handler->setDeferred(flag);
}
 
 
bool Attribute::isExpression() const {
    return base->isExpression();
}
 
 
bool Attribute::isReadOnly() const {
    return handler->isReadOnly();
}
 
 
void Attribute::setReadOnly(bool flag) {
    handler->setReadOnly(flag);
}
 
 
void Attribute::parse(Statement &stat, bool eval) {
    handler->parse(*this, stat, eval);
    isDefault = false;
}
 
 
void Attribute::parseComponent(Statement &stat, bool eval, int index) {
    handler->parseComponent(*this, stat, eval, index);
    isDefault = false;
}
 
 
void Attribute::set(AttributeBase *newBase) {
    base = std::shared_ptr<AttributeBase>(newBase);
    isDefault = false;
}
 
 
void Attribute::setDefault() {
    base = std::shared_ptr<AttributeBase>(handler->getDefault());
    isDefault = true;
}
 
 
void Attribute::print(int &pos) const {
    if(*this) {
        std::string name  = getName();
        std::string image = getImage();
        int step = name.length() + image.length() + 2;
        pos += step;
 
        if(pos > 74) {
            *gmsg << ',' << endl << "  ";
            pos = step + 2;
        } else {
            *gmsg << ',';
        }
        *gmsg << name << (isExpression() ? ":=" : "=") << image;
    }
}
 
 
std::ostream &operator<<(std::ostream &os, const Attribute &attr) {
    if(attr) {
        attr.getBase().print(os);
    } else {
        os << "*undefined*";
    }
 
    return os;
}