Class DebugSync

cpp/src/arrow/acero/asof_join_node.cc:162–211

A debug-facility that wraps output-stream insertions with synchronization. Code like DebugSync(as_of_join_node) << ... << ... << ... ; will insert to the node's debug-stream and guard all insertions as one operation using the node's debug-mutex. However, it is recommended to use the DEBUG_SYNC macro, defined below it. Code like DEBUG_SYNC(as_of_join_node, ..., ..., ...); will do the same if N

//
//   DEBUG_SYNC(as_of_join_node, ... , DEBUG_MANIP(std::endl) , ...);
class DebugSync {
 public:
  explicit DebugSync(AsofJoinNode* node)
      : debug_os_(GetDebugStream(node)),
        debug_mutex_(GetDebugMutex(node)),
        alt_debug_mutex_(),  // an alternative debug-mutex, if the node has none
        debug_lock_(debug_mutex_ ? *debug_mutex_ : alt_debug_mutex_) {
    if (debug_os_) {
      std::ios state(NULL);
      state.copyfmt(*debug_os_);
      (*debug_os_) << "AsofjoinNode(" << std::hex << &node << "): ";
      debug_os_->copyfmt(state);
    }
  }

  DebugSync& operator<<(std::ostream& (*pf)(std::ostream&)) {
    if (debug_os_) pf(*debug_os_);
    return *this;
  }
  DebugSync& operator<<(std::ios& (*pf)(std::ios&)) {
    if (debug_os_) pf(*debug_os_);
    return *this;
  }
  DebugSync& operator<<(std::ios_base& (*pf)(std::ios_base&)) {
    if (debug_os_) pf(*debug_os_);
    return *this;
  }

  // used by DEBUG_MANIP macro below
  using Manip = std::function<DebugSync&(DebugSync&)>;
  DebugSync& operator<<(Manip f) { return f(*this); }

  template <typename T>
  DebugSync& operator<<(T&& value) {
    if (debug_os_) (*debug_os_) << value;
    return *this;
  }

  // used by DEBUG_SYNC macro below
  template <typename... Args>
  DebugSync& insert(Args&&... args) {
    return (*this << ... << args);
  }

 private:
  std::ostream* debug_os_;
  std::mutex* debug_mutex_;
  std::mutex alt_debug_mutex_;
  std::unique_lock<std::mutex> debug_lock_;
};

#  define DEBUG_SYNC(node, ...) DebugSync(node).insert(__VA_ARGS__)
#  define DEBUG_MANIP(manip) \