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 <iostream>
#include <set>
 
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;
}