adapter.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2025, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include <atomic>
#include <memory>
#include <optional>
#include <stdexcept>
#include <string>
#include <type_traits>
 
namespace kcenon::common::adapters {
 
// Forward declarations
class adapter_base;
 
template<typename T>
struct adapter_traits;
 
template<typename T>
struct adapter_traits {
    using value_type = T;
    using pointer_type = T*;
    using reference_type = T&;
    using const_reference_type = const T&;
    static constexpr bool is_smart_pointer = false;
    static constexpr bool supports_weak = false;
};
 
template<typename T>
struct adapter_traits<std::shared_ptr<T>> {
    using value_type = T;
    using pointer_type = std::shared_ptr<T>;
    using reference_type = T&;
    using const_reference_type = const T&;
    using weak_type = std::weak_ptr<T>;
    static constexpr bool is_smart_pointer = true;
    static constexpr bool supports_weak = true;
};
 
template<typename T, typename Deleter>
struct adapter_traits<std::unique_ptr<T, Deleter>> {
    using value_type = T;
    using pointer_type = std::unique_ptr<T, Deleter>;
    using reference_type = T&;
    using const_reference_type = const T&;
    static constexpr bool is_smart_pointer = true;
    static constexpr bool supports_weak = false;
};
 
class adapter_base {
public:
    virtual ~adapter_base() = default;
 
    virtual size_t get_adapter_depth() const = 0;
 
    virtual bool is_adapter() const { return true; }
 
    virtual size_t get_type_id() const = 0;
};
 
template<typename T, typename Traits = adapter_traits<T>>
class adapter {
public:
    using value_type = typename Traits::value_type;
    using pointer_type = typename Traits::pointer_type;
    using reference_type = typename Traits::reference_type;
    using const_reference_type = typename Traits::const_reference_type;
 
    explicit adapter(T value) : value_(std::move(value)) {}
 
    adapter() requires std::is_default_constructible_v<T> : value_() {}
 
    auto get() const noexcept {
        if constexpr (Traits::is_smart_pointer) {
            return value_.get();
        } else {
            return std::addressof(value_);
        }
    }
 
    decltype(auto) operator*() const {
        if constexpr (Traits::is_smart_pointer) {
            return *value_;
        } else {
            return value_;
        }
    }
 
    decltype(auto) operator*() {
        if constexpr (Traits::is_smart_pointer) {
            return *value_;
        } else {
            return value_;
        }
    }
 
    auto operator->() const noexcept { return get(); }
 
    auto operator->() noexcept { return get(); }
 
    auto weak() const requires(Traits::supports_weak) {
        return typename Traits::weak_type(value_);
    }
 
    explicit operator bool() const noexcept {
        if constexpr (Traits::is_smart_pointer) {
            return static_cast<bool>(value_);
        } else {
            return true; // Value types are always valid
        }
    }
 
    const T& value() const& noexcept { return value_; }
 
    T& value() & noexcept { return value_; }
 
    T value() && noexcept { return std::move(value_); }
 
    T release() noexcept { return std::move(value_); }
 
    static constexpr bool is_smart_pointer() noexcept {
        return Traits::is_smart_pointer;
    }
 
    static constexpr bool supports_weak() noexcept {
        return Traits::supports_weak;
    }
 
private:
    T value_;
};
 
// Deduction guides
template<typename T>
adapter(T) -> adapter<T>;
 
template<typename T>
adapter(std::shared_ptr<T>) -> adapter<std::shared_ptr<T>>;
 
template<typename T, typename D>
adapter(std::unique_ptr<T, D>) -> adapter<std::unique_ptr<T, D>>;
 
template<typename T, typename... Args>
auto make_adapter(Args&&... args) {
    return adapter<T>(T(std::forward<Args>(args)...));
}
 
template<typename T, typename... Args>
auto make_shared_adapter(Args&&... args) {
    return adapter(std::make_shared<T>(std::forward<Args>(args)...));
}
 
template<typename T, typename... Args>
auto make_unique_adapter(Args&&... args) {
    return adapter(std::make_unique<T>(std::forward<Args>(args)...));
}
 
template<typename Interface, typename Implementation>
class interface_adapter : public Interface, public adapter_base {
public:
    explicit interface_adapter(std::shared_ptr<Implementation> impl)
        : impl_(impl), wrapper_depth_(calculate_depth(impl)) {
        if (wrapper_depth_ > max_wrapper_depth_) {
            throw std::runtime_error(
                "Adapter chain too deep (" + std::to_string(wrapper_depth_) +
                " levels, max: " + std::to_string(max_wrapper_depth_) + ")");
        }
    }
 
    virtual ~interface_adapter() = default;
 
    std::shared_ptr<Implementation> unwrap() const { return impl_; }
 
    bool is_wrapped_adapter() const { return wrapper_depth_ > 0; }
 
    size_t get_wrapper_depth() const { return wrapper_depth_; }
 
    size_t get_adapter_depth() const override { return wrapper_depth_; }
 
    static std::string adapter_type_name() {
        return "interface_adapter<Interface, Implementation>";
    }
 
    static constexpr size_t max_depth() { return max_wrapper_depth_; }
 
    size_t get_type_id() const override { return get_static_type_id(); }
 
    static size_t get_static_type_id() {
        static const size_t id = generate_type_id();
        return id;
    }
 
protected:
    std::shared_ptr<Implementation> impl_;
 
private:
    size_t wrapper_depth_;
    static constexpr size_t max_wrapper_depth_ = 2;
 
    static size_t generate_type_id() {
        static std::atomic<size_t> counter{0};
        return ++counter;
    }
 
    static size_t calculate_depth(std::shared_ptr<Implementation> impl) {
        if (!impl) {
            return 0;
        }
 
        if constexpr (std::is_base_of_v<adapter_base, Implementation>) {
#ifdef __cpp_rtti
            if (auto* base_adapter =
                    dynamic_cast<adapter_base*>(impl.get())) {
                return 1 + base_adapter->get_adapter_depth();
            }
            return 0;
#else
            auto* base_adapter = static_cast<adapter_base*>(impl.get());
            if (base_adapter && base_adapter->get_type_id() != 0) {
                return 1 + base_adapter->get_adapter_depth();
            }
            return 0;
#endif
        }
 
        return 0;
    }
};
 
template<typename T, typename Interface>
inline constexpr bool implements_interface_v =
    std::is_base_of_v<Interface, T> || std::is_convertible_v<T*, Interface*>;
 
class adapter_factory {
public:
    template<typename Interface, typename Impl>
    static std::shared_ptr<Interface>
    create(std::shared_ptr<Impl> impl) {
        if constexpr (implements_interface_v<Impl, Interface>) {
            return std::static_pointer_cast<Interface>(impl);
        } else {
            return std::make_shared<interface_adapter<Interface, Impl>>(impl);
        }
    }
 
    template<typename AdapterType, typename... Args>
    static std::shared_ptr<AdapterType> create_explicit(Args&&... args) {
        return std::make_shared<AdapterType>(std::forward<Args>(args)...);
    }
 
    template<typename T, typename Interface>
    static std::shared_ptr<T> try_unwrap(std::shared_ptr<Interface> ptr) {
        if (!ptr) {
            return nullptr;
        }
 
        if constexpr (std::is_base_of_v<adapter_base, Interface>) {
#ifdef __cpp_rtti
            if (auto* adapter =
                    dynamic_cast<interface_adapter<Interface, T>*>(ptr.get())) {
                return adapter->unwrap();
            }
#else
            auto* base = static_cast<adapter_base*>(ptr.get());
            if (base && base->get_type_id() ==
                            interface_adapter<Interface, T>::get_static_type_id()) {
                auto* adapter =
                    static_cast<interface_adapter<Interface, T>*>(ptr.get());
                return adapter->unwrap();
            }
#endif
        }
 
        return nullptr;
    }
 
    template<typename Interface, typename Impl>
    static constexpr bool is_zero_cost() {
        return implements_interface_v<Impl, Interface>;
    }
};
 
template<typename T, typename Interface>
std::shared_ptr<T> safe_unwrap(std::shared_ptr<Interface> ptr) {
    return adapter_factory::try_unwrap<T, Interface>(ptr);
}
 
template<typename Interface>
bool is_adapter(std::shared_ptr<Interface> ptr) {
    if (!ptr) {
        return false;
    }
 
    if constexpr (std::is_base_of_v<adapter_base, Interface>) {
        auto* base = static_cast<adapter_base*>(ptr.get());
        return base->is_adapter();
    }
 
    return false;
}
 
template<typename Interface, typename Impl>
std::shared_ptr<Interface> make_interface_adapter(std::shared_ptr<Impl> impl) {
    return adapter_factory::create<Interface, Impl>(impl);
}
 
template<typename T, typename Interface>
std::shared_ptr<T> unwrap_adapter(std::shared_ptr<Interface> ptr) {
    return adapter_factory::try_unwrap<T, Interface>(ptr);
}
 
} // namespace kcenon::common::adapters