// Copyright (c) 2011-present, Facebook, Inc. All rights reserved.
//  This source code is licensed under both the GPLv2 (found in the
//  COPYING file in the root directory) and Apache 2.0 License
//  (found in the LICENSE.Apache file in the root directory).

#pragma once

#include <functional>

#include "rocksdb/rocksdb_namespace.h"

namespace ROCKSDB_NAMESPACE {

// Defers the execution of the provided function until the Defer
// object goes out of scope.
//
// Usage example:
//
// Status DeferTest() {
//   Status s;
//   Defer defer([&s]() {
//     if (!s.ok()) {
//       // do cleanups ...
//     }
//   });
//   // do something ...
//   if (!s.ok()) return;
//   // do some other things ...
//   return s;
// }
//
// The above code ensures that cleanups will always happen on returning.
//
// Without the help of Defer, you can
// 1. every time when !s.ok(), do the cleanup;
// 2. instead of returning when !s.ok(), continue the work only when s.ok(),
//    but sometimes, this might lead to nested blocks of "if (s.ok()) {...}".
//
// With the help of Defer, you can centralize the cleanup logic inside the
// lambda passed to Defer, and you can return immediately on failure when
// necessary.
class Defer final {
 public:
  explicit Defer(std::function<void()>&& fn) : fn_(std::move(fn)) {}
  ~Defer() { fn_(); }

  // Disallow copy.
  Defer(const Defer&) = delete;
  Defer& operator=(const Defer&) = delete;

 private:
  std::function<void()> fn_;
};

// An RAII utility object that saves the current value of an object so that
// it can be overwritten, and restores it to the saved value when the
// SaveAndRestore object goes out of scope.
template <typename T>
class SaveAndRestore {
 public:
  // obj is non-null pointer to value to be saved and later restored.
  explicit SaveAndRestore(T* obj) : obj_(obj), saved_(*obj) {}
  // new_value is stored in *obj
  SaveAndRestore(T* obj, const T& new_value)
      : obj_(obj), saved_(std::move(*obj)) {
    *obj = new_value;
  }
  SaveAndRestore(T* obj, T&& new_value) : obj_(obj), saved_(std::move(*obj)) {
    *obj = std::move(new_value);
  }
  ~SaveAndRestore() { *obj_ = std::move(saved_); }

  // No copies
  SaveAndRestore(const SaveAndRestore&) = delete;
  SaveAndRestore& operator=(const SaveAndRestore&) = delete;

 private:
  T* const obj_;
  T saved_;
};

}  // namespace ROCKSDB_NAMESPACE