Function AllocateUnique

common/memory.h:673–703

template <typename T, typename... Args>
Unique<T> AllocateUnique(Allocator<> allocator, Args&&... args) {
  using U = std::remove_cv_t<T>;
  static_assert(!std::is_reference_v<U>, "T must not be a reference");
  static_assert(!std::is_array_v<U>, "T must not be an array");

  U* object;
  google::protobuf::Arena* absl_nullable arena = allocator.arena();
  bool unowned;
  if constexpr (google::protobuf::Arena::is_arena_constructable<U>::value) {
    object = google::protobuf::Arena::Create<U>(arena, std::forward<Args>(args)...);
    // For arena-compatible proto types, let the Arena::Create handle
    // registering the destructor call.
    // Otherwise, Unique<T> retains a pointer to the owning arena so it may
    // conditionally register T::~T depending on usage.
    unowned = false;
  } else {
    void* p = allocator.allocate_bytes(sizeof(U), alignof(U));
    CEL_INTERNAL_TRY {
      if constexpr (ArenaTraits<>::constructible<U>()) {
        object = ::new (p) U(arena, std::forward<Args>(args)...);
      } else {
        object = ::new (p) U(std::forward<Args>(args)...);
      }
    }
    CEL_INTERNAL_CATCH_ANY {
      allocator.deallocate_bytes(p, sizeof(U), alignof(U));
      CEL_INTERNAL_RETHROW;
    }
    unowned =
        arena != nullptr && !ArenaTraits<>::trivially_destructible(*object);
  }
  return Unique<T>(object, arena, unowned);
}