wrapper_base.h

// Copyright (c) 2009-2025 Avanquest Software. All rights reserved.
 
#ifndef PDFSDK_CXX_PDF_WRAPPER_BASE_H_INCLUDED_
#define PDFSDK_CXX_PDF_WRAPPER_BASE_H_INCLUDED_
 
#include <cassert>
#include <utility>
 
#include <pdfsdk/core/init.h>
#include <pdfsdk/cxx/exception.h>
 
namespace PDF {
 
#define PDF_CXX_CORE_WRAPPER_DEFINE_MEMBERS_(Class, HandleType)          \
public:                                                                  \
    Class() noexcept {                                                   \
    }                                                                    \
    Class(HandleType handle, bool adopt = false) noexcept                \
            : detail::RefCountedHandle<HandleType>(handle, adopt) {      \
    }                                                                    \
    Class(const Class& rhs) noexcept                                     \
            : detail::RefCountedHandle<HandleType>(rhs) {                \
    }                                                                    \
    Class& operator=(const Class& rhs) noexcept {                        \
        detail::RefCountedHandle<HandleType>::operator=(rhs);            \
        return *this;                                                    \
    }                                                                    \
    Class(Class&& rhs) noexcept                                          \
            : detail::RefCountedHandle<HandleType>(std::move(rhs)) {     \
    }                                                                    \
    Class& operator=(Class&& rhs) noexcept {                             \
        detail::RefCountedHandle<HandleType>::operator=(std::move(rhs)); \
        return *this;                                                    \
    }
 
#ifdef SWIG
#undef PDF_CXX_CORE_WRAPPER_DEFINE_MEMBERS_
#define PDF_CXX_CORE_WRAPPER_DEFINE_MEMBERS_(Class, HandleType) \
public:                                                         \
    Class() noexcept;                                           \
    Class(const Class& rhs) noexcept;
#endif
 
namespace detail {
 
template<typename HandleType>
class RefCountedHandle {
protected:
    ~RefCountedHandle() {
        Release();
    }
 
    RefCountedHandle() noexcept
            : m_handle(nullptr) {
    }
 
    RefCountedHandle(HandleType handle, bool adopt = false) noexcept
            : m_handle(handle) {
        if (!adopt)
            Acquire();
    }
 
    RefCountedHandle(const RefCountedHandle& that) noexcept
            : m_handle(that.m_handle) {
        Acquire();
    }
 
    RefCountedHandle& operator=(const RefCountedHandle& rhs) noexcept {
        if (this != &rhs)
            reset(rhs.m_handle);
        return *this;
    }
 
    RefCountedHandle(RefCountedHandle&& that) noexcept
            : m_handle(that.m_handle) {
        that.m_handle = nullptr;
    }
 
    RefCountedHandle& operator=(RefCountedHandle&& rhs) noexcept {
        Release();
        m_handle = rhs.m_handle;
        rhs.m_handle = nullptr;
        return *this;
    }
 
public:
    void reset(HandleType handle, bool adopt = false) noexcept {
        if (m_handle != handle) {
            Release();
            m_handle = handle;
            if (!adopt)
                Acquire();
        } else {
            assert(!adopt);
        }
    }
 
    void reset() noexcept {
        reset(nullptr);
    }
 
    HandleType* operator&() noexcept {
        assert(!m_handle);
        return &m_handle;
    }
 
    HandleType get() const noexcept { return m_handle; }
 
    HandleType detach() noexcept { return std::exchange(m_handle, nullptr); }
 
    bool operator==(const RefCountedHandle& rhs) const noexcept = default;
 
    bool operator==(const HandleType& handle) const noexcept { return (m_handle == handle); }
    friend bool operator==(const HandleType& handle, const RefCountedHandle& wrapper) noexcept { return (wrapper == handle); }
 
    bool operator!=(const HandleType& handle) const noexcept { return !(*this == handle); }
    friend bool operator!=(const HandleType& handle, const RefCountedHandle& wrapper) noexcept { return (wrapper != handle); }
 
    explicit operator bool() const noexcept { return !!m_handle; }
 
    bool operator<(const RefCountedHandle& rhs) const noexcept { return m_handle < rhs.m_handle; }
 
private:
    void Acquire() noexcept {
        if (m_handle)
            PDHandleAcquire(m_handle);
    }
    void Release() noexcept {
        if (m_handle)
            PDHandleRelease(m_handle);
    }
 
protected:
    HandleType m_handle;
};
 
}  // namespace detail
}  // namespace PDF
 
#endif  // PDFSDK_CXX_PDF_WRAPPER_BASE_H_INCLUDED_