misc_utils.hpp

#ifndef DITTO_MISC_UTILS_H
#define DITTO_MISC_UTILS_H
 
// Properly implementing the (move/copy) assignment operators is tricky/subtle,
// and there is actually a safer pattern to achieve this:
//  1. list all the ownership-sensitive fields, especially those playing a
//  role w.r.t. explicit `~Type()` dtor glue;
//  2. implement some `(Type &, Type &)` `swap`ping function which swaps each of
//  these fields
//     (often _via_ `std::swap()`);
//  3. write the assignment ctors using the following pattern, or by directly
//  invoking this macro.
// Notes:
//  - `MoveOrCopy` is expected to be `&& other` or `const& other`,
//  - `move_or_copy` is then expected to be `std::move(other)` or `other`,
//  respectively.
// NOLINTBEGIN
#define DEFINE_ASSIGNMENT_OPERATOR_USING_SWAP(Type, MoveOrCopy, move_or_copy,  \
                                              swap_function)                   \
  Type &Type::operator=(Type MoveOrCopy) {                                     \
    {                                                                          \
      if (this == &other) {                                                    \
        return *this;                                                          \
      }                                                                        \
      Type temporary{move_or_copy};                                            \
      swap_function(other, *this);                                             \
    }                                                                          \
                                                                               \
    return *this;                                                              \
  }                                                                            \
  static_assert(true, "") // <- require semicolon after the macro invocation.
// NOLINTEND
#endif