NodeId.h

#ifndef ROSE_AST_NodeId_H
#define ROSE_AST_NodeId_H
#include <RoseFirst.h>
 
#include <string>
#include <limits>
 
#define NODEID_INCLUDE_ROSE_VERSION 1
 
 
class SgNode;
 
namespace Rose { namespace AST {
 
    class ROSE_DLL_API NodeId {
 
    private:  
 
    // \brief private internal constructor
    NodeId(size_t poolId, size_t nodeId, SgNode* inNode) : poolIndex(poolId), nodeIndex(nodeId), node(inNode) {} 
 
    //(Never called publically)
    static void initRunHash(); 
 
    
    //DATA---------------------  
    //I'm not that concerned about data size because these aren't stored for each node, they can be
    //recomputed at will
    // The number of the memory pool this node lives at
    size_t poolIndex;
    // The index of this item in the memory pool 
    size_t nodeIndex;
  
    SgNode* node;
    
    static std::string run_hash;
    
    public:
    NodeId() : poolIndex(std::numeric_limits<size_t>::max()), nodeIndex(std::numeric_limits<size_t>::max()), node(nullptr) {}
 
    NodeId(SgNode* sgnode); 
 
    NodeId(const NodeId &rhs) : poolIndex(rhs.poolIndex), nodeIndex(rhs.nodeIndex), node(rhs.node) {}
 
    NodeId& operator=(const NodeId& rhs) {
      poolIndex = rhs.poolIndex;
      nodeIndex = rhs.nodeIndex;
      node = rhs.node;
      return *this;
    }
  
    static NodeId getId(SgNode *node);
 
    static NodeId getId(const std::string& nodeIdString); 
 
    static SgNode *getNode(const std::string& nodeIdString) {
      return getId(nodeIdString).getNode();
    }
 
    SgNode* getNode() const { return node;};
  
    std::string toString() const;
 
    bool operator==(const NodeId& rhs) const {
      if(poolIndex == rhs.poolIndex &&
         nodeIndex == rhs.nodeIndex &&
         node == rhs.node) {
        return true;
      }
      return false;
    }
 
    bool operator!=(const NodeId& rhs) const { return !(this->operator==(rhs)); }
    bool operator< (const NodeId& rhs) const {     
      if(poolIndex < rhs.poolIndex ||
         nodeIndex < rhs.nodeIndex ||
         node < rhs.node) { //Should never reach this comparison...  
        return true;
      }
      return false;
    }
    bool operator<= (const NodeId& rhs) const {     
      if(poolIndex <= rhs.poolIndex ||
         nodeIndex <= rhs.nodeIndex ||
         node <= rhs.node) { //Should never reach this comparison...  
        return true;
      }
      return false;
    }
 
    bool operator> (const NodeId& rhs) const { return !(this->operator<=(rhs));}
    bool operator>=(const NodeId& rhs) const { return !(this->operator< (rhs));}
  
    };
    
  } }
 
#endif /* ROSE_AST_NodeId_H */