make Node::in_edge_ private

11 files changed, 44 insertions, 43 deletions

diff --git a/src/build.cc b/src/build.cc
index e109535..3b478fa 100644
--- a/src/build.cc
+++ b/src/build.cc
@@ -190,7 +190,7 @@ bool Plan::AddTarget(Node* node, string* err) {
 }
 
 bool Plan::AddSubTarget(Node* node, vector<Node*>* stack, string* err) {
-  Edge* edge = node->in_edge_;
+  Edge* edge = node->in_edge();
   if (!edge) {  // Leaf node.
     if (node->dirty()) {
       string referenced;
@@ -201,7 +201,6 @@ bool Plan::AddSubTarget(Node* node, vector<Node*>* stack, string* err) {
     }
     return false;
   }
-  assert(edge);
 
   if (CheckDependencyCycle(node, stack, err))
     return false;
@@ -455,7 +454,7 @@ Node* Builder::AddTarget(const string& name, string* err) {
 
 bool Builder::AddTarget(Node* node, string* err) {
   node->StatIfNecessary(disk_interface_);
-  if (Edge* in_edge = node->in_edge_) {
+  if (Edge* in_edge = node->in_edge()) {
     if (!in_edge->RecomputeDirty(state_, disk_interface_, err))
       return false;
     if (in_edge->outputs_ready())
diff --git a/src/build_test.cc b/src/build_test.cc
index 5a95701..43d5c47 100644
--- a/src/build_test.cc
+++ b/src/build_test.cc
@@ -221,7 +221,7 @@ void BuildTest::Dirty(const string& path) {
 
   // If it's an input file, mark that we've already stat()ed it and
   // it's missing.
-  if (!node->in_edge_)
+  if (!node->in_edge())
     node->MarkMissing();
 }
 
diff --git a/src/clean.cc b/src/clean.cc
index c768629..dcdff84 100644
--- a/src/clean.cc
+++ b/src/clean.cc
@@ -119,10 +119,10 @@ int Cleaner::CleanAll(bool generator) {
 }
 
 void Cleaner::DoCleanTarget(Node* target) {
-  if (target->in_edge_) {
+  if (target->in_edge()) {
     Remove(target->path());
-    for (vector<Node*>::iterator n = target->in_edge_->inputs_.begin();
-         n != target->in_edge_->inputs_.end();
+    for (vector<Node*>::iterator n = target->in_edge()->inputs_.begin();
+         n != target->in_edge()->inputs_.end();
          ++n) {
       DoCleanTarget(*n);
     }
diff --git a/src/disk_interface_test.cc b/src/disk_interface_test.cc
index a39c06a..0ca34ad 100644
--- a/src/disk_interface_test.cc
+++ b/src/disk_interface_test.cc
@@ -195,8 +195,7 @@ TEST_F(StatTest, Simple) {
   Node* out = GetNode("out");
   out->Stat(this);
   ASSERT_EQ(1u, stats_.size());
-  Edge* edge = out->in_edge_;
-  edge->RecomputeDirty(NULL, this, NULL);
+  out->in_edge()->RecomputeDirty(NULL, this, NULL);
   ASSERT_EQ(2u, stats_.size());
   ASSERT_EQ("out", stats_[0]);
   ASSERT_EQ("in",  stats_[1]);
@@ -210,8 +209,7 @@ TEST_F(StatTest, TwoStep) {
   Node* out = GetNode("out");
   out->Stat(this);
   ASSERT_EQ(1u, stats_.size());
-  Edge* edge = out->in_edge_;
-  edge->RecomputeDirty(NULL, this, NULL);
+  out->in_edge()->RecomputeDirty(NULL, this, NULL);
   ASSERT_EQ(3u, stats_.size());
   ASSERT_EQ("out", stats_[0]);
   ASSERT_TRUE(GetNode("out")->dirty());
@@ -229,8 +227,7 @@ TEST_F(StatTest, Tree) {
   Node* out = GetNode("out");
   out->Stat(this);
   ASSERT_EQ(1u, stats_.size());
-  Edge* edge = out->in_edge_;
-  edge->RecomputeDirty(NULL, this, NULL);
+  out->in_edge()->RecomputeDirty(NULL, this, NULL);
   ASSERT_EQ(1u + 6u, stats_.size());
   ASSERT_EQ("mid1", stats_[1]);
   ASSERT_TRUE(GetNode("mid1")->dirty());
@@ -249,8 +246,7 @@ TEST_F(StatTest, Middle) {
   Node* out = GetNode("out");
   out->Stat(this);
   ASSERT_EQ(1u, stats_.size());
-  Edge* edge = out->in_edge_;
-  edge->RecomputeDirty(NULL, this, NULL);
+  out->in_edge()->RecomputeDirty(NULL, this, NULL);
   ASSERT_FALSE(GetNode("in")->dirty());
   ASSERT_TRUE(GetNode("mid")->dirty());
   ASSERT_TRUE(GetNode("out")->dirty());
diff --git a/src/graph.cc b/src/graph.cc
index 4de7226..15df856 100644
--- a/src/graph.cc
+++ b/src/graph.cc
@@ -42,7 +42,7 @@ bool Edge::RecomputeDirty(State* state, DiskInterface* disk_interface,
   time_t most_recent_input = 1;
   for (vector<Node*>::iterator i = inputs_.begin(); i != inputs_.end(); ++i) {
     if ((*i)->StatIfNecessary(disk_interface)) {
-      if (Edge* edge = (*i)->in_edge_) {
+      if (Edge* edge = (*i)->in_edge()) {
         if (!edge->RecomputeDirty(state, disk_interface, err))
           return false;
       } else {
@@ -52,7 +52,7 @@ bool Edge::RecomputeDirty(State* state, DiskInterface* disk_interface,
     }
 
     // If an input is not ready, neither are our outputs.
-    if (Edge* edge = (*i)->in_edge_) {
+    if (Edge* edge = (*i)->in_edge()) {
       if (!edge->outputs_ready_)
         outputs_ready_ = false;
     }
@@ -146,7 +146,7 @@ bool Edge::RecomputeOutputDirty(BuildLog* build_log, time_t most_recent_input,
 bool Edge::AllInputsReady() const {
   for (vector<Node*>::const_iterator i = inputs_.begin();
        i != inputs_.end(); ++i) {
-    if ((*i)->in_edge_ && !(*i)->in_edge_->outputs_ready())
+    if ((*i)->in_edge() && !(*i)->in_edge()->outputs_ready())
       return false;
   }
   return true;
@@ -239,9 +239,9 @@ bool Edge::LoadDepFile(State* state, DiskInterface* disk_interface,
     // If we don't have a edge that generates this input already,
     // create one; this makes us not abort if the input is missing,
     // but instead will rebuild in that circumstance.
-    if (!node->in_edge_) {
+    if (!node->in_edge()) {
       Edge* phony_edge = state->AddEdge(&State::kPhonyRule);
-      node->in_edge_ = phony_edge;
+      node->set_in_edge(phony_edge);
       phony_edge->outputs_.push_back(node);
 
       // RecomputeDirty might not be called for phony_edge if a previous call
diff --git a/src/graph.h b/src/graph.h
index 694cf35..b6f5139 100644
--- a/src/graph.h
+++ b/src/graph.h
@@ -68,6 +68,9 @@ struct Node {
   void set_dirty(bool dirty) { dirty_ = dirty; }
   void MarkDirty() { dirty_ = true; }
 
+  Edge* in_edge() const { return in_edge_; }
+  void set_in_edge(Edge* edge) { in_edge_ = edge; }
+
 private:
   string path_;
   /// Possible values of mtime_:
@@ -81,10 +84,13 @@ private:
   /// edges to build.
   bool dirty_;
 
+  /// The Edge that produces this Node, or NULL when there is no
+  /// known edge to produce it.
+  Edge* in_edge_;
+
   // TODO: make these private as well.  But don't just blindly add
   // setters/getters, instead pay attention to the proper API.
 public:
-  Edge* in_edge_;
   vector<Edge*> out_edges_;
 };
 
diff --git a/src/graph_test.cc b/src/graph_test.cc
index ab2213a..c1a0f93 100644
--- a/src/graph_test.cc
+++ b/src/graph_test.cc
@@ -26,7 +26,7 @@ TEST_F(GraphTest, MissingImplicit) {
   fs_.Create("in", 1, "");
   fs_.Create("out", 1, "");
 
-  Edge* edge = GetNode("out")->in_edge_;
+  Edge* edge = GetNode("out")->in_edge();
   string err;
   EXPECT_TRUE(edge->RecomputeDirty(&state_, &fs_, &err));
   ASSERT_EQ("", err);
@@ -44,7 +44,7 @@ TEST_F(GraphTest, ModifiedImplicit) {
   fs_.Create("out", 1, "");
   fs_.Create("implicit", 2, "");
 
-  Edge* edge = GetNode("out")->in_edge_;
+  Edge* edge = GetNode("out")->in_edge();
   string err;
   EXPECT_TRUE(edge->RecomputeDirty(&state_, &fs_, &err));
   ASSERT_EQ("", err);
@@ -64,7 +64,7 @@ TEST_F(GraphTest, FunkyMakefilePath) {
   fs_.Create("out.o.d", 1, "out.o: ./foo/../implicit.h\n");
   fs_.Create("out.o", 1, "");
 
-  Edge* edge = GetNode("out.o")->in_edge_;
+  Edge* edge = GetNode("out.o")->in_edge();
   string err;
   EXPECT_TRUE(edge->RecomputeDirty(&state_, &fs_, &err));
   ASSERT_EQ("", err);
@@ -87,7 +87,7 @@ TEST_F(GraphTest, ExplicitImplicit) {
   fs_.Create("out.o.d", 1, "out.o: implicit.h\n");
   fs_.Create("out.o", 1, "");
 
-  Edge* edge = GetNode("out.o")->in_edge_;
+  Edge* edge = GetNode("out.o")->in_edge();
   string err;
   EXPECT_TRUE(edge->RecomputeDirty(&state_, &fs_, &err));
   ASSERT_EQ("", err);
@@ -108,7 +108,7 @@ TEST_F(GraphTest, PathWithCurrentDirectory) {
   fs_.Create("out.o.d", 1, "out.o: foo.cc\n");
   fs_.Create("out.o", 1, "");
 
-  Edge* edge = GetNode("out.o")->in_edge_;
+  Edge* edge = GetNode("out.o")->in_edge();
   string err;
   EXPECT_TRUE(edge->RecomputeDirty(&state_, &fs_, &err));
   ASSERT_EQ("", err);
diff --git a/src/graphviz.cc b/src/graphviz.cc
index aa5bb08..d5dbcd0 100644
--- a/src/graphviz.cc
+++ b/src/graphviz.cc
@@ -25,14 +25,14 @@ void GraphViz::AddTarget(Node* node) {
   printf("\"%p\" [label=\"%s\"]\n", node, node->path().c_str());
   visited_.insert(node);
 
-  if (!node->in_edge_) {
+  Edge* edge = node->in_edge();
+
+  if (!edge) {
     // Leaf node.
     // Draw as a rect?
     return;
   }
 
-  Edge* edge = node->in_edge_;
-
   if (edge->inputs_.size() == 1 && edge->outputs_.size() == 1) {
     // Can draw simply.
     // Note extra space before label text -- this is cosmetic and feels
diff --git a/src/ninja.cc b/src/ninja.cc
index f0525fb..1024401 100644
--- a/src/ninja.cc
+++ b/src/ninja.cc
@@ -203,10 +203,10 @@ int CmdQuery(State* state, int argc, char* argv[]) {
     Node* node = state->LookupNode(argv[i]);
     if (node) {
       printf("%s:\n", argv[i]);
-      if (node->in_edge_) {
-        printf("  input: %s\n", node->in_edge_->rule_->name_.c_str());
-        for (vector<Node*>::iterator in = node->in_edge_->inputs_.begin();
-             in != node->in_edge_->inputs_.end(); ++in) {
+      if (node->in_edge()) {
+        printf("  input: %s\n", node->in_edge()->rule_->name_.c_str());
+        for (vector<Node*>::iterator in = node->in_edge()->inputs_.begin();
+             in != node->in_edge()->inputs_.end(); ++in) {
           printf("    %s\n", (*in)->path().c_str());
         }
       }
@@ -258,10 +258,10 @@ int CmdTargetsList(const vector<Node*>& nodes, int depth, int indent) {
     for (int i = 0; i < indent; ++i)
       printf("  ");
     const char* target = (*n)->path().c_str();
-    if ((*n)->in_edge_) {
-      printf("%s: %s\n", target, (*n)->in_edge_->rule_->name_.c_str());
+    if ((*n)->in_edge()) {
+      printf("%s: %s\n", target, (*n)->in_edge()->rule_->name_.c_str());
       if (depth > 1 || depth <= 0)
-        CmdTargetsList((*n)->in_edge_->inputs_, depth - 1, indent + 1);
+        CmdTargetsList((*n)->in_edge()->inputs_, depth - 1, indent + 1);
     } else {
       printf("%s\n", target);
     }
@@ -280,7 +280,7 @@ int CmdTargetsSourceList(State* state) {
     for (vector<Node*>::iterator inps = (*e)->inputs_.begin();
          inps != (*e)->inputs_.end();
          ++inps)
-      if (!(*inps)->in_edge_)
+      if (!(*inps)->in_edge())
         printf("%s\n", (*inps)->path().c_str());
   return 0;
 }
@@ -383,7 +383,7 @@ void PrintCommands(Edge* edge, set<Edge*>* seen) {
 
   for (vector<Node*>::iterator in = edge->inputs_.begin();
        in != edge->inputs_.end(); ++in)
-    PrintCommands((*in)->in_edge_, seen);
+    PrintCommands((*in)->in_edge(), seen);
 
   if (!edge->is_phony())
     puts(edge->EvaluateCommand().c_str());
@@ -399,7 +399,7 @@ int CmdCommands(State* state, int argc, char* argv[]) {
 
   set<Edge*> seen;
   for (vector<Node*>::iterator in = nodes.begin(); in != nodes.end(); ++in)
-    PrintCommands((*in)->in_edge_, &seen);
+    PrintCommands((*in)->in_edge(), &seen);
 
   return 0;
 }
diff --git a/src/parsers_test.cc b/src/parsers_test.cc
index 4ef4edb..7b502f8 100644
--- a/src/parsers_test.cc
+++ b/src/parsers_test.cc
@@ -441,7 +441,7 @@ TEST_F(ParserTest, Implicit) {
 "rule cat\n  command = cat $in > $out\n"
 "build foo: cat bar | baz\n"));
 
-  Edge* edge = state.LookupNode("foo")->in_edge_;
+  Edge* edge = state.LookupNode("foo")->in_edge();
   ASSERT_TRUE(edge->is_implicit(1));
 }
 
@@ -450,7 +450,7 @@ TEST_F(ParserTest, OrderOnly) {
 "rule cat\n  command = cat $in > $out\n"
 "build foo: cat bar || baz\n"));
 
-  Edge* edge = state.LookupNode("foo")->in_edge_;
+  Edge* edge = state.LookupNode("foo")->in_edge();
   ASSERT_TRUE(edge->is_order_only(1));
 }
 
diff --git a/src/state.cc b/src/state.cc
index 1635f31..930c361 100644
--- a/src/state.cc
+++ b/src/state.cc
@@ -89,11 +89,11 @@ void State::AddIn(Edge* edge, const string& path) {
 void State::AddOut(Edge* edge, const string& path) {
   Node* node = GetNode(path);
   edge->outputs_.push_back(node);
-  if (node->in_edge_) {
+  if (node->in_edge()) {
     Warning("multiple rules generate %s. "
             "build will not be correct; continuing anyway", path.c_str());
   }
-  node->in_edge_ = edge;
+  node->set_in_edge(edge);
 }
 
 bool State::AddDefault(const string& path, string* err) {