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) {} 

    
    //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;

  
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 */