Rename function to tryUpdateState in Futures FSM

Summary: [Folly] Rename function to `tryUpdateState` in Futures `FSM` for clarity.

Reviewed By: LeeHowes

Differential Revision: D7725949

fbshipit-source-id: ccda21d990dbedfc4d0b86ab7cfb8eb68d93e429

folly/futures/detail/FSM.h

@@ -50,7 +50,7 @@ class FSM {
   /// The action will see the old state.
   /// @returns true on success, false and action unexecuted otherwise
   template <class F>
-  bool updateState(Enum A, Enum B, F const& action) {
+  bool tryUpdateState(Enum A, Enum B, F const& action) {
     std::lock_guard<Mutex> lock(mutex_);
     if (state_.load(std::memory_order_acquire) != A) {
       return false;
@@ -69,7 +69,7 @@ class FSM {
   ///   while (!done) {
   ///     switch (getState()) {
   ///     case State::Foo:
-  ///       done = updateState(State::Foo, State::Bar,
+  ///       done = tryUpdateState(State::Foo, State::Bar,
   ///           [&]{ /* do protected stuff */ },
   ///           [&]{ /* do unprotected stuff */});
   ///       break;
@@ -78,7 +78,7 @@ class FSM {
   ///   while (true) {
   ///     switch (getState()) {
   ///     case State::Foo:
-  ///       if (!updateState(State::Foo, State::Bar,
+  ///       if (!tryUpdateState(State::Foo, State::Bar,
   ///           [&]{ /* do protected stuff */ })) {
   ///         continue;
   ///       }
@@ -88,9 +88,12 @@ class FSM {
   /// The protected action will see the old state, and the unprotected action
   /// will see the new state.
   template <class F1, class F2>
-  bool updateState(Enum A, Enum B,
-                   F1 const& protectedAction, F2 const& unprotectedAction) {
-    bool result = updateState(A, B, protectedAction);
+  bool tryUpdateState(
+      Enum A,
+      Enum B,
+      F1 const& protectedAction,
+      F2 const& unprotectedAction) {
+    bool result = tryUpdateState(A, B, protectedAction);
     if (result) {
       unprotectedAction();
     }
@@ -101,9 +104,8 @@ class FSM {
 #define FSM_START(fsm) {\
     bool done = false; \
     while (!done) { auto state = fsm.getState(); switch (state) {
-
 #define FSM_UPDATE2(fsm, b, protectedAction, unprotectedAction) \
-    done = fsm.updateState(state, (b), (protectedAction), (unprotectedAction));
+  done = fsm.tryUpdateState(state, (b), (protectedAction), (unprotectedAction));
 
 #define FSM_UPDATE(fsm, b, action) FSM_UPDATE2(fsm, (b), (action), []{})
 

folly/futures/test/FSMTest.cpp

@@ -30,10 +30,10 @@ TEST(FSM, example) {
   auto tryTransition = [&]{
     switch (fsm.getState()) {
     case State::A:
-      return fsm.updateState(State::A, State::B, [&]{ count++; });
+      return fsm.tryUpdateState(State::A, State::B, [&] { count++; });
     case State::B:
-      return fsm.updateState(State::B, State::A,
-                             [&]{ count--; }, [&]{ unprotectedCount--; });
+      return fsm.tryUpdateState(
+          State::B, State::A, [&] { count--; }, [&] { unprotectedCount--; });
     }
     return false; // unreachable
   };
@@ -90,31 +90,31 @@ TEST(FSM, ctor) {
 
 TEST(FSM, update) {
   FSM<State, std::mutex> fsm(State::A);
-  EXPECT_TRUE(fsm.updateState(State::A, State::B, []{}));
+  EXPECT_TRUE(fsm.tryUpdateState(State::A, State::B, [] {}));
   EXPECT_EQ(State::B, fsm.getState());
 }
 
 TEST(FSM, badUpdate) {
   FSM<State, std::mutex> fsm(State::A);
-  EXPECT_FALSE(fsm.updateState(State::B, State::A, []{}));
+  EXPECT_FALSE(fsm.tryUpdateState(State::B, State::A, [] {}));
 }
 
 TEST(FSM, actionOnUpdate) {
   FSM<State, std::mutex> fsm(State::A);
   int count = 0;
-  fsm.updateState(State::A, State::B, [&]{ count++; });
+  fsm.tryUpdateState(State::A, State::B, [&] { count++; });
   EXPECT_EQ(1, count);
 }
 
 TEST(FSM, noActionOnBadUpdate) {
   FSM<State, std::mutex> fsm(State::A);
   int count = 0;
-  fsm.updateState(State::B, State::A, [&]{ count++; });
+  fsm.tryUpdateState(State::B, State::A, [&] { count++; });
   EXPECT_EQ(0, count);
 }
 
 TEST(FSM, stateTransitionAfterAction) {
   FSM<State, std::mutex> fsm(State::A);
-  fsm.updateState(State::A, State::B,
-                  [&]{ EXPECT_EQ(State::A, fsm.getState()); });
+  fsm.tryUpdateState(
+      State::A, State::B, [&] { EXPECT_EQ(State::A, fsm.getState()); });
 }