foobar, C++ (vc++)

Language: Layout:

#include <iostream>
#include <utility>

#define FORWARD(x) std::forward<decltype(x)>(x)

template <typename T, typename Accessor, typename Mutator,
          typename StateT =
              decltype(std::declval<Accessor>()(std::declval<T &>()))>
struct guard {
  guard(T &x, Accessor const &a, Mutator const &m)
      : object{&x}, accessor{a}, mutator{m}, state{accessor(x)} {}
  ~guard() {
    if (object)
      mutator(*object, state);
  }

private:
  T *object;
  Accessor accessor;
  Mutator mutator;
  StateT state;
};

template <typename T, typename Accessor, typename Mutator>
guard<T, Accessor, Mutator> make_guard(T &t, Accessor &&a,
                                               Mutator &&m) {
  return guard<T, Accessor, Mutator>{t, std::forward<Accessor>(a),
                                             std::forward<Mutator>(m)};
}

template <typename... Ts> struct overloaded;
template <typename First, typename... Rest>
struct overloaded<First, Rest...> : public First,
                                    public overloaded<Rest...>::type {
  overloaded(First first, Rest... rest)
      : First(first), overloaded<Rest...>::type(rest...) {}

using type = overloaded<First, Rest...>;
  using overloaded<Rest...>::type::operator();

using First::operator();
};

template <typename Last> struct overloaded<Last> : Last {
  using type = Last;
  using Last::operator();
};

template <typename... Fns> constexpr auto make_overloaded(Fns &&... fns) {
  return overloaded<Fns...>{std::forward<Fns>(fns)...};
}

#define EXPECTED_ACCESSOR_NAME(state_name) get_##state_name
#define ACCESSOR_OBJECT(state_name)                                            \
  [](auto &&x) -> decltype(auto) {                                             \
    return make_overloaded(                                                    \
        [](auto &&x,                                                           \
           int) -> decltype(FORWARD(x).EXPECTED_ACCESSOR_NAME(state_name)()) { \
          return FORWARD(x).EXPECTED_ACCESSOR_NAME(state_name)();              \
        },                                                                     \
        [](auto &&x...) -> decltype(FORWARD(x).state_name) {                   \
          return FORWARD(x).state_name;                                        \
        })(FORWARD(x), 0);                                                     \
  }
#define EXPECTED_MUTATOR_NAME(state_name) set_##state_name
#define MUTATOR_OBJECT(state_name)                                             \
  [](auto &&x, auto &&new_state) -> decltype(auto) {                           \
    return make_overloaded(                                                    \
        [](auto &&x, auto &&new_state, int)                                    \
            -> decltype(FORWARD(x).EXPECTED_MUTATOR_NAME(state_name)(          \
                FORWARD(new_state))) {                                         \
          return FORWARD(x).EXPECTED_MUTATOR_NAME(state_name)(                 \
              FORWARD(new_state));                                             \
        },                                                                     \
        [](auto &&x, auto &&new_state,                                         \
           ...) -> decltype(FORWARD(x).state_name = FORWARD(new_state)) {      \
          return FORWARD(x).state_name = FORWARD(new_state);                   \
        })(FORWARD(x), FORWARD(new_state), 0);                                 \
  }

#define GUARD(guard_name, object_name, state_name)                             \
  auto guard_name {                                                            \
    make_guard(object_name, ACCESSOR_OBJECT(state_name),                       \
               MUTATOR_OBJECT(state_name))                                     \
  }

struct Foo {
  void set_value(int new_value) { value = new_value; }
  int get_value() const { return value; }

private:
  int value = 24;
};
#include <functional>
int main() {
  Foo x;
  std::cout << "x.get_value(): " << x.get_value() << '\n';
  {
    // Declare an object named my_guard which saves and restores x.value
    // automatically.
    GUARD(my_guard, x, value);
    // modify and use x.value here
    x.set_value(42);
    std::cout << "x.value has been modified.\n";
    std::cout << "x.get_value(): " << x.get_value() << '\n';

} // x.value is automagically restored here
  std::cout << "x.value has been restored.\n";
  std::cout << "x.get_value(): " << x.get_value() << '\n';
}

Show compiler warnings [ + ] Compiler args [ + ] Show input
Compilation time: 1,59 sec, absolute service time: 1,61 sec