UniquePtr.hpp

/* Copyright 2024-2025 Franz Poeschel
 *
 * This file is part of openPMD-api.
 *
 * openPMD-api is free software: you can redistribute it and/or modify
 * it under the terms of of either the GNU General Public License or
 * the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * openPMD-api is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License and the GNU Lesser General Public License
 * for more details.
 *
 * You should have received a copy of the GNU General Public License
 * and the GNU Lesser General Public License along with openPMD-api.
 * If not, see <http://www.gnu.org/licenses/>.
 */
 
#pragma once
 
#include <functional>
#include <iostream>
#include <memory>
#include <type_traits>
 
namespace openPMD
{
 
namespace auxiliary
{
    template <typename T>
    class CustomDelete : public std::function<void(std::remove_extent_t<T> *)>
    {
    private:
        using T_decayed = std::remove_extent_t<T>;
 
    public:
        using deleter_type = std::function<void(T_decayed *)>;
 
        /*
         * Default constructor: Use std::default_delete<T>.
         * This ensures correct destruction of arrays by using delete[].
         */
        CustomDelete();
 
        CustomDelete(deleter_type func);
    };
} // namespace auxiliary

template <typename T>
class UniquePtrWithLambda
    : public std::unique_ptr<
          T,
          /* Deleter = */ auxiliary::CustomDelete<T>>
{
private:
    using BasePtr = std::unique_ptr<T, auxiliary::CustomDelete<T>>;
 
public:
    using T_decayed = std::remove_extent_t<T>;
 
    UniquePtrWithLambda();
 
    UniquePtrWithLambda(UniquePtrWithLambda &&) noexcept;
    UniquePtrWithLambda &operator=(UniquePtrWithLambda &&) noexcept;
 
    UniquePtrWithLambda(UniquePtrWithLambda const &) = delete;
    UniquePtrWithLambda &operator=(UniquePtrWithLambda const &) = delete;

    template <
        typename bare_unique_ptr,
        typename SFINAE = std::enable_if_t<
            std::is_same_v<bare_unique_ptr, std::unique_ptr<T>>>>
    UniquePtrWithLambda(bare_unique_ptr);

    template <
        typename Del,
        typename SFINAE = std::enable_if_t<
            !std::is_same_v<std::unique_ptr<T, Del>, std::unique_ptr<T>>>>
    UniquePtrWithLambda(std::unique_ptr<T, Del>);

    UniquePtrWithLambda(T_decayed *);

    UniquePtrWithLambda(T_decayed *, std::function<void(T_decayed *)>);

    template <typename U>
    UniquePtrWithLambda<U> static_cast_() &&;
};
 
template <typename T>
template <typename Del, typename>
UniquePtrWithLambda<T>::UniquePtrWithLambda(std::unique_ptr<T, Del> ptr)
    : BasePtr{ptr.release(), auxiliary::CustomDelete<T>{[&]() {
                  if constexpr (std::is_copy_constructible_v<Del>)
                  {
                      return [deleter = std::move(ptr.get_deleter())](
                                 T_decayed *del_ptr) { deleter(del_ptr); };
                  }
                  else
                  {
                      /*
                       * The constructor of std::function requires a copyable
                       * lambda. Since Del is not a copyable type, we cannot
                       * capture it directly, but need to put it into a
                       * shared_ptr to make it copyable.
                       */
                      return [deleter = std::make_shared<Del>(
                                  std::move(ptr.get_deleter()))](
                                 T_decayed *del_ptr) { (*deleter)(del_ptr); };
                  }
              }()}}
{}
 
template <typename T>
template <typename U>
UniquePtrWithLambda<U> UniquePtrWithLambda<T>::static_cast_() &&
{
    using other_type = std::remove_extent_t<U>;
    return UniquePtrWithLambda<U>{
        static_cast<other_type *>(this->release()),
        [deleter = std::move(this->get_deleter())](other_type *ptr) {
            deleter(static_cast<T_decayed *>(ptr));
        }};
}
} // namespace openPMD