AstAttributeMechanism.h

#ifndef ROSE_AstAttributeMechanism_H
#define ROSE_AstAttributeMechanism_H
 
#include "rosedll.h"
#include <Sawyer/Attribute.h>
#include <list>
#include <set>
 
class SgNode;
class SgNamedType;
class SgTemplateParameter;
class SgTemplateParameterList;
 
class ROSE_DLL_API AstAttribute {
public:
    enum OwnershipPolicy {
        CONTAINER_OWNERSHIP,                            
        NO_OWNERSHIP,                                   
        CUSTOM_OWNERSHIP,                               
        UNKNOWN_OWNERSHIP                               
    };
 
    virtual OwnershipPolicy getOwnershipPolicy() const;
 
    class ROSE_DLL_API AttributeEdgeInfo {
    public:
        SgNode* fromNode;
        SgNode* toNode;
        std::string label;
        std::string options;
 
        AttributeEdgeInfo(SgNode* fromNode, SgNode* toNode, std::string label, std::string options)
            : fromNode(fromNode), toNode(toNode), label(label), options(options) {}
 
        ~AttributeEdgeInfo() {
            fromNode = NULL;
            toNode = NULL;
        };
    };
 
    class ROSE_DLL_API AttributeNodeInfo {
    public:
        SgNode* nodePtr;
        std::string label;
        std::string options;
 
        AttributeNodeInfo(SgNode* nodePtr, std::string label, std::string options)
            : nodePtr(nodePtr), label(label), options(options) {}
 
        ~AttributeNodeInfo() {};
    };
 
public:
    AstAttribute() {}
    virtual ~AstAttribute() {}
 
    virtual AstAttribute* constructor() const {
        return new AstAttribute;                        // it doesn't make much sense to instantiate this type!
    }
 
    virtual AstAttribute* copy() const {
        return NULL;                                    // attribute will not be copied when the containing obj is copied
    }
 
    // DO NOT DOCUMENT!  The original implementation used a non-const copy constructor and many subclasses that implemented a
    // copy constructor didn't use C++11's "override" word as a defensive measure. Since we don't have access to all those
    // subclasses, we must continue to support the non-const version.  Subclasses should only have to implement one or the
    // other, not both.
    virtual AstAttribute* copy() {
        return const_cast<const AstAttribute*>(this)->copy();
    }
 
    virtual std::string attribute_class_name() const {
        return "AstAttribute";                          // almost certainly not the right dynamic type name!
    }
 
    virtual std::string toString();
 
    virtual int packed_size();
    virtual char* packed_data();
    virtual void unpacked_data( int size, char* data );
    virtual std::string additionalNodeOptions();
    virtual std::vector<AttributeEdgeInfo> additionalEdgeInfo();
    virtual std::vector<AttributeNodeInfo> additionalNodeInfo();
    virtual bool commentOutNodeInGraph();
};
 
 
class ROSE_DLL_API AstAttributeMechanism {
    // Use containment because we want to keep the original API.
    Sawyer::Attribute::Storage<> attributes_;
 
public:
    AstAttributeMechanism() {}
 
    AstAttributeMechanism(const AstAttributeMechanism &other) {
        assignFrom(other);
    }
 
    AstAttributeMechanism& operator=(const AstAttributeMechanism &other);
 
    ~AstAttributeMechanism();
 
    bool exists(const std::string &name) const;
 
    void set(const std::string &name, AstAttribute *value);
 
    bool add(const std::string &name, AstAttribute *value);
 
    bool replace(const std::string &name, AstAttribute *value);
 
    AstAttribute* operator[](const std::string &name) const;
 
    void remove(const std::string &name);
 
    typedef std::set<std::string> AttributeIdentifiers;
 
    AttributeIdentifiers getAttributeIdentifiers() const;
 
    size_t size() const;
 
private:
    // Called by copy constructor and assignment.
    void assignFrom(const AstAttributeMechanism &other);
};
 
 
 
class ROSE_DLL_API MetricAttribute: public AstAttribute {
protected:
    bool is_derived_;
    double value_;
 
public:
    MetricAttribute()
        : is_derived_(false), value_(0) {}
    
    MetricAttribute(double value, bool is_derived=false)
        : is_derived_(is_derived), value_(value) {}
    
    virtual AstAttribute* copy() const override;
    virtual std::string attribute_class_name() const override;
 
    virtual bool isDerived() const { return is_derived_; }
    virtual double getValue()  const { return value_; }
    virtual void setValue(double newVal) { value_ = newVal; }
 
    virtual std::string toString() override;
 
    virtual int packed_size() override;
    virtual char* packed_data() override;
    virtual void unpacked_data(int size, char* data) override;
 
    MetricAttribute& operator+=(const MetricAttribute &other);
    MetricAttribute& operator-=(const MetricAttribute &other);
    MetricAttribute& operator*=(const MetricAttribute &other);
    MetricAttribute& operator/=(const MetricAttribute &other);
};
 
 
template<class T>
class ROSE_DLL_API AstValueAttribute: public AstAttribute {
public:
    typedef T Value;
private:
    Value value_;
public:
    AstValueAttribute() {}
 
    explicit AstValueAttribute(const T &value): value_(value) {}
 
    AstValueAttribute(const AstValueAttribute &other): value_(other.value_) {}
 
    virtual AstAttribute* copy() const override { return new AstValueAttribute(*this); }
    virtual std::string attribute_class_name() const override { return "AstValueAttribute"; }
 
    const T& get() const { return value_; }
    T& get() { return value_; }
    void set(const T& value) { value_ = value; }
};
 
// DQ (11/21/2009): Added new kind of attribute for handling regex trees.
class ROSE_DLL_API AstRegExAttribute: public AstAttribute {
public:
    std::string expression;
 
    AstRegExAttribute() {}
    
    explicit AstRegExAttribute(const std::string & s)
        : expression(s) {}
 
    virtual AstAttribute* copy() const override {
        return new AstRegExAttribute(*this);
    }
 
    virtual std::string attribute_class_name() const override {
        return "AstRegExAttribute";
    }
};
 
 
// PC (10/21/2012): Added new kind of attribute for handling regex trees.
class ROSE_DLL_API AstSgNodeAttribute: public AstValueAttribute<SgNode*> {
public:
    typedef AstValueAttribute<SgNode*> Super;
    AstSgNodeAttribute(): Super(NULL) {}
    explicit AstSgNodeAttribute(SgNode *value): Super(value) {}
    AstSgNodeAttribute(const AstSgNodeAttribute &other): Super(other) {}
    virtual AstAttribute* copy() const override { return new AstSgNodeAttribute(*this); }
    virtual std::string attribute_class_name() const override { return "AstSgNodeAttribute"; }
    SgNode* getNode() { return get(); }
    void setNode(SgNode *node) { set(node); }
};
 
class ROSE_DLL_API AstSgNodeListAttribute: public AstValueAttribute<std::vector<SgNode*> > {
public:
    typedef AstValueAttribute<std::vector<SgNode*> > Super;
    AstSgNodeListAttribute() {}
    explicit AstSgNodeListAttribute(std::vector<SgNode *> &value): Super(value) {}
    AstSgNodeListAttribute(const AstSgNodeListAttribute &other): Super(other) {}
    virtual AstAttribute* copy() const override { return new AstSgNodeListAttribute(*this); }
    virtual std::string attribute_class_name() const override { return "AstSgNodeListAttribute"; }
    std::vector<SgNode*> &getNodeList() { return get(); }
    void addNode(SgNode *n) { get().push_back(n); }
    void setNode(SgNode*, int);
    SgNode *getNode(int);
    int size() { return get().size(); }
};
 
class ROSE_DLL_API AstIntAttribute : public AstValueAttribute<int> {
public:
    typedef AstValueAttribute<int> Super;
    AstIntAttribute(): Super(0) {}
    explicit AstIntAttribute(int value): Super(value) {}
    AstIntAttribute(const AstIntAttribute &other): Super(other) {}
    virtual AstAttribute* copy() const override { return new AstIntAttribute(*this); }
    virtual std::string attribute_class_name() const override { return "AstIntAttribute"; }
    int getValue() { return get(); }
};
 
#endif