dependency.h

#ifndef GRAPHTOOL_DEPENDENCY_H
#define GRAPHTOOL_DEPENDENCY_H

#include <string>
#include "mem_type.h"

template<class T1, class T2> class Dependency {

  public:

    Dependency(T1* from, T2* to, bool is_absolute = false) {
      from_ = from;
      to_ = to;
      is_absolute_ = is_absolute;
      type_ = GraphTool::UNDEFINED; // temporary
    }
    
    void remove_from_datastructure() {
      to_->remove_dependent(from_);
      from_->remove_dependency(to_);
    } 

    T1* from() {
      return from_;
    }

    T2* to() {
      return to_;
    }

    const T1* from_const() const {
      return from_;
    }

        const T2* to_const() const {
            return to_;
        }
    
    bool absolute() const {
      return is_absolute_;
    }

    bool relative() const {
      return !is_absolute_;
    }
        
    void set_absolute() {
      is_absolute_ = true;
    }

    void set_relative() {
      is_absolute_ = false;
    }
    
    GraphTool::MemType type() const {
      return type_;
    }

    GraphTool::MemType type() {
      return type_;
    }
    
    std::string type_string() {
      if(type_ == GraphTool::LDM) {
        return "LDM";
      } else if (type_ == GraphTool::LPM) {
        return "LPM";
      } else if (type_ == GraphTool::LDM_LPM) {
        return "LDM_LPM";
      }
      return "UNDEFINED";
    }
        
    void set_type(GraphTool::MemType type) const {
      type_ = type;
    }

  private:
    T1* from_;
    T2* to_;
    bool is_absolute_;
    mutable GraphTool::MemType type_;
};

#endif