Tag.hpp

Go to the documentation of this file.

// <Tag.hpp> -*- C++ -*-
 
 
#pragma once
 
#include <inttypes.h>
#include <string>
#include "sparta/utils/SpartaException.hpp"
#include "sparta/utils/SpartaAssert.hpp"
 
namespace sparta
{
 
class Tag
{
    typedef uint32_t SequenceType;
public:
    Tag() :
        this_seq_ (global_seq_++)
    {}
 
    Tag(const Tag& other) = default;
 
    Tag(Tag* parent) :
        parent_(parent)
    {
        if(SPARTA_EXPECT_TRUE(parent != nullptr)) {
            this_seq_ = parent->child_seq_;
            ++(parent->child_seq_);
        }
        else {
            this_seq_ = global_seq_++;
        }
    }
 
    operator std::string() const
    {
        std::stringstream ss;
        if(parent_) {
            ss << std::string(*parent_) << '.' << this_seq_;
        }
        else {
            ss << this_seq_;
        }
        return ss.str();
    }
 
    bool operator==(const Tag& other) const
    {
        if(parent_) {
            if(other.parent_ == nullptr) {
                // not equivalent, not the same hierarchy
                return false;
            }
            return (this_seq_ == other.this_seq_) &&
                (*parent_ == *other.parent_);
        }
        else {
            if(other.parent_ != nullptr) {
                // not equivalent, not the same hierarchy
                return false;
            }
            return (this_seq_ == other.this_seq_);
        }
    }
 
    bool operator!=(const Tag& other) const
    {
        return !operator==(other);
    }
 
    bool operator==(const std::string& s) const
    {
        return (std::string(*this) == s);
    }
 
    bool operator!=(const std::string& s) const
    {
        return !operator==(s);
    }
 
    static void resetGlobalSeqNum() {
        global_seq_ = 1;
    }
 
private:
    Tag                    *parent_     = nullptr; 
    SequenceType            this_seq_  = 0; 
    SequenceType            child_seq_ = 1; 
    static SequenceType     global_seq_;    
};
 
inline std::ostream& operator<<(std::ostream& os, const Tag& tag)
{
    os << std::string(tag);
    return os;
}
 
inline std::ostream& operator<<(std::ostream& os, const Tag* tag)
{
    if (tag != nullptr) {
        os << std::string(*tag);
    } else {
        // throw an exception here?
        os << "NULL TAG";
    }
 
    return os;
}
 
 
} // sparta
 
#define SPARTA_TAG_BODY                           \
    namespace sparta {                            \
        Tag::SequenceType Tag::global_seq_ = 1; \
    }