NodeId.h

#ifndef ROSE_AST_NodeId_H
#define ROSE_AST_NodeId_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 */