Cosmetic changes

[invirt/third/libt4.git] / log.cc

diff --git a/log.cc b/log.cc
index 95c40e3..decb827 100644 (file)
--- a/log.cc
+++ b/log.cc
@@ -12,11 +12,11 @@ log::log(proposer_acceptor *_acc, string _me) : pxs (_acc) {
 }
 
 void log::logread(void) {
 }
 
 void log::logread(void) {

-    ifstream from(name);
+    std::ifstream from(name);

     string type;
     unsigned instance;
 
     string type;
     unsigned instance;
 

-    LOG("logread");
+    LOG << "logread";

     while (from >> type) {
         if (type == "done") {
             string v;
     while (from >> type) {
         if (type == "done") {
             string v;

@@ -25,23 +25,23 @@ void log::logread(void) {
             getline(from, v);
             pxs->values[instance] = v;
             pxs->instance_h = instance;
             getline(from, v);
             pxs->values[instance] = v;
             pxs->instance_h = instance;

-            LOG("logread: instance: " << instance << " w. v = " <<
-                    pxs->values[instance]);
-            pxs->v_a.clear();
-            pxs->n_h.n = 0;
-            pxs->n_a.n = 0;
+            LOG << "logread: instance: " << instance << " w. v = "
+                << pxs->values[instance];
+            pxs->accepted_value.clear();
+            pxs->promise.n = 0;
+            pxs->accepted.n = 0;

         } else if (type == "propseen") {
         } else if (type == "propseen") {

-            from >> pxs->n_h.n >> pxs->n_h.m;
-            LOG("logread: high update: " << pxs->n_h.n << "(" << pxs->n_h.m << ")");
+            from >> pxs->promise.n >> pxs->promise.m;
+            LOG << "logread: high update: " << pxs->promise.n << "(" << pxs->promise.m << ")";

         } else if (type == "accepted") {
             string v;
         } else if (type == "accepted") {
             string v;

-            from >> pxs->n_a.n >> pxs->n_a.m;
+            from >> pxs->accepted.n >> pxs->accepted.m;

             from.get();
             getline(from, v);
             from.get();
             getline(from, v);

-            pxs->v_a = v;
-            LOG("logread: prop update " << pxs->n_a.n << "(" << pxs->n_a.m << ") with v = " << pxs->v_a);
+            pxs->accepted_value = v;
+            LOG << "logread: prop update " << pxs->accepted.n << "(" << pxs->accepted.m << ") with v = " << pxs->accepted_value;

         } else {
         } else {

-            LOG("logread: unknown log record");
+            LOG << "logread: unknown log record";

             VERIFY(0);
         }
     } 
             VERIFY(0);
         }
     } 

@@ -49,41 +49,41 @@ void log::logread(void) {
 }
 
 string log::dump() {
 }
 
 string log::dump() {

-    ifstream from(name);
+    std::ifstream from(name);

     string res;
     string v;
     string res;
     string v;

-    while (getline(from, v))
+    while (std::getline(from, v))

         res += v + "\n";
     from.close();
     return res;
 }
 
 void log::restore(string s) {
         res += v + "\n";
     from.close();
     return res;
 }
 
 void log::restore(string s) {

-    LOG("restore: " << s);
-    ofstream f(name, std::ios::trunc);
+    LOG << "restore: " << s;
+    std::ofstream f(name, std::ios::trunc);

     f << s;
     f.close();
 }
 
 // XXX should be an atomic operation
 void log::loginstance(unsigned instance, string v) {
     f << s;
     f.close();
 }
 
 // XXX should be an atomic operation
 void log::loginstance(unsigned instance, string v) {

-    ofstream f(name, std::ios::app);
+    std::ofstream f(name, std::ios::app);

     f << "done " << instance << " " << v << "\n";
     f.close();
 }
 
     f << "done " << instance << " " << v << "\n";
     f.close();
 }
 

-// an acceptor should call logprop(n_h) when it
+// an acceptor should call logprop(promise) when it

 // receives a prepare to which it responds prepare_ok().
 // receives a prepare to which it responds prepare_ok().

-void log::logprop(prop_t n_h) {
-    ofstream f(name, std::ios::app);
-    f << "propseen " << n_h.n << " " << n_h.m << "\n";
+void log::logprop(prop_t promise) {
+    std::ofstream f(name, std::ios::app);
+    f << "propseen " << promise.n << " " << promise.m << "\n";

     f.close();
 }
 
     f.close();
 }
 

-// an acceptor should call logaccept(n_a, v_a) when it
+// an acceptor should call logaccept(accepted, accepted_value) when it

 // receives an accept RPC to which it replies accept_ok().
 void log::logaccept(prop_t n, string v) {
 // receives an accept RPC to which it replies accept_ok().
 void log::logaccept(prop_t n, string v) {

-    ofstream f(name, std::ios::app);
+    std::ofstream f(name, std::ios::app);

     f << "accepted " << n.n << " " << n.m << " " << v << "\n";
     f.close();
 }
     f << "accepted " << n.n << " " << n.m << " " << v << "\n";
     f.close();
 }