GraphNode.hpp

Go to the documentation of this file.

#ifndef MESHKIT_GRAPH_NODE_HPP
#define MESHKIT_GRAPH_NODE_HPP

#include "lemon/list_graph.h"
#include <string>

namespace MeshKit {

class MKGraph;
    
class GraphNode
{
public:


  friend class MKGraph;
  
  GraphNode(const GraphNode &graph_node);
  
  GraphNode(MKGraph *graph);

  virtual ~GraphNode();
  
  MKGraph *get_graph() const;

  lemon::ListDigraph::Node get_node() const;

  lemon::ListDigraph::InArcIt in_arcs() const;
  
  lemon::ListDigraph::OutArcIt out_arcs() const;

  GraphNode *other_node(lemon::ListDigraph::Arc arc);

  virtual std::string get_name() const;

  virtual void set_name(std::string new_name);

  virtual void setup_this() = 0;

  virtual void execute_this() = 0;

  bool setup_called() const;
  
  void setup_called(bool flag);
  
  bool execute_called() const;
  
  void execute_called(bool flag);
  
protected:
  MKGraph *mkGraph;

  lemon::ListDigraph::Node graphNode;

  std::string nodeName;

  bool setupCalled;
  
  bool executeCalled;
  
private:
};

inline GraphNode::GraphNode(const GraphNode &node) 
        : mkGraph(node.get_graph()), nodeName(node.get_name()), 
          setupCalled(node.setup_called()), executeCalled(node.execute_called())
{
    // create a node for this meshop
  graphNode = get_graph()->get_graph().addNode();

    // this is a copy; set in/out edges from copied node
  for (lemon::ListDigraph::InArcIt ait(get_graph()->get_graph(), node.get_node());
       ait != lemon::INVALID; ++ait) 
    get_graph()->get_graph().addArc(get_graph()->source(ait)->get_node(), graphNode);
  for (lemon::ListDigraph::OutArcIt ait(get_graph()->get_graph(), node.get_node());
       ait != lemon::INVALID; ++ait) 
    get_graph()->get_graph().addArc(graphNode, get_graph()->target(ait)->get_node());
}
    
inline GraphNode::GraphNode(MKGraph *graph) 
        : mkGraph(graph), nodeName(), setupCalled(false), executeCalled(false)
{
    // create a Lemon node 
  graphNode = graph->get_graph().addNode();

    // set the nodemap value for this meshop
  graph->node_map()[graphNode] = this;
  
    // might not be root/leaf nodes yet, if this is a root or leaf node being created
  if (graph->root_node() && graph->leaf_node()) {
    graph->get_graph().addArc(graph->root_node()->get_node(), graphNode);
    graph->get_graph().addArc(graphNode, graph->leaf_node()->get_node());
  }
}

inline GraphNode::~GraphNode() 
{
  get_graph()->node_map()[graphNode] = NULL;
  get_graph()->get_graph().erase(graphNode);
}

inline std::string GraphNode::get_name() const
{
  return nodeName;
}

inline void GraphNode::set_name(std::string new_name)
{
  nodeName = new_name;
}

inline lemon::ListDigraph::InArcIt GraphNode::in_arcs() const
{
  return lemon::ListDigraph::InArcIt(get_graph()->get_graph(), graphNode);
}

inline lemon::ListDigraph::OutArcIt GraphNode::out_arcs() const
{
  return lemon::ListDigraph::OutArcIt(get_graph()->get_graph(), graphNode);
}

inline MKGraph *GraphNode::get_graph() const
{
  return mkGraph;
}

inline lemon::ListDigraph::Node GraphNode::get_node() const
{
  return graphNode;
}

inline GraphNode *GraphNode::other_node(lemon::ListDigraph::Arc arc)
{
  return get_graph()->other_node(arc, this);
}

inline bool GraphNode::setup_called() const
{
  return setupCalled;
}

inline void GraphNode::setup_called(bool flag) {
  setupCalled = flag;
}

inline bool GraphNode::execute_called() const
{
  return executeCalled;
}

inline void GraphNode::execute_called(bool flag) {
  executeCalled = flag;
}

} // namespace MeshKit

#endif